diff.con commit Refactor handling of error_string in receive-pack (8aaf7d6)
   1/*
   2 * Copyright (C) 2005 Junio C Hamano
   3 */
   4#include "cache.h"
   5#include "quote.h"
   6#include "diff.h"
   7#include "diffcore.h"
   8#include "delta.h"
   9#include "xdiff-interface.h"
  10#include "color.h"
  11
  12#ifdef NO_FAST_WORKING_DIRECTORY
  13#define FAST_WORKING_DIRECTORY 0
  14#else
  15#define FAST_WORKING_DIRECTORY 1
  16#endif
  17
  18static int use_size_cache;
  19
  20static int diff_detect_rename_default;
  21static int diff_rename_limit_default = -1;
  22static int diff_use_color_default;
  23
  24static char diff_colors[][COLOR_MAXLEN] = {
  25        "\033[m",       /* reset */
  26        "",             /* PLAIN (normal) */
  27        "\033[1m",      /* METAINFO (bold) */
  28        "\033[36m",     /* FRAGINFO (cyan) */
  29        "\033[31m",     /* OLD (red) */
  30        "\033[32m",     /* NEW (green) */
  31        "\033[33m",     /* COMMIT (yellow) */
  32        "\033[41m",     /* WHITESPACE (red background) */
  33};
  34
  35static int parse_diff_color_slot(const char *var, int ofs)
  36{
  37        if (!strcasecmp(var+ofs, "plain"))
  38                return DIFF_PLAIN;
  39        if (!strcasecmp(var+ofs, "meta"))
  40                return DIFF_METAINFO;
  41        if (!strcasecmp(var+ofs, "frag"))
  42                return DIFF_FRAGINFO;
  43        if (!strcasecmp(var+ofs, "old"))
  44                return DIFF_FILE_OLD;
  45        if (!strcasecmp(var+ofs, "new"))
  46                return DIFF_FILE_NEW;
  47        if (!strcasecmp(var+ofs, "commit"))
  48                return DIFF_COMMIT;
  49        if (!strcasecmp(var+ofs, "whitespace"))
  50                return DIFF_WHITESPACE;
  51        die("bad config variable '%s'", var);
  52}
  53
  54/*
  55 * These are to give UI layer defaults.
  56 * The core-level commands such as git-diff-files should
  57 * never be affected by the setting of diff.renames
  58 * the user happens to have in the configuration file.
  59 */
  60int git_diff_ui_config(const char *var, const char *value)
  61{
  62        if (!strcmp(var, "diff.renamelimit")) {
  63                diff_rename_limit_default = git_config_int(var, value);
  64                return 0;
  65        }
  66        if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff")) {
  67                diff_use_color_default = git_config_colorbool(var, value);
  68                return 0;
  69        }
  70        if (!strcmp(var, "diff.renames")) {
  71                if (!value)
  72                        diff_detect_rename_default = DIFF_DETECT_RENAME;
  73                else if (!strcasecmp(value, "copies") ||
  74                         !strcasecmp(value, "copy"))
  75                        diff_detect_rename_default = DIFF_DETECT_COPY;
  76                else if (git_config_bool(var,value))
  77                        diff_detect_rename_default = DIFF_DETECT_RENAME;
  78                return 0;
  79        }
  80        if (!prefixcmp(var, "diff.color.") || !prefixcmp(var, "color.diff.")) {
  81                int slot = parse_diff_color_slot(var, 11);
  82                color_parse(value, var, diff_colors[slot]);
  83                return 0;
  84        }
  85        return git_default_config(var, value);
  86}
  87
  88static char *quote_one(const char *str)
  89{
  90        int needlen;
  91        char *xp;
  92
  93        if (!str)
  94                return NULL;
  95        needlen = quote_c_style(str, NULL, NULL, 0);
  96        if (!needlen)
  97                return xstrdup(str);
  98        xp = xmalloc(needlen + 1);
  99        quote_c_style(str, xp, NULL, 0);
 100        return xp;
 101}
 102
 103static char *quote_two(const char *one, const char *two)
 104{
 105        int need_one = quote_c_style(one, NULL, NULL, 1);
 106        int need_two = quote_c_style(two, NULL, NULL, 1);
 107        char *xp;
 108
 109        if (need_one + need_two) {
 110                if (!need_one) need_one = strlen(one);
 111                if (!need_two) need_one = strlen(two);
 112
 113                xp = xmalloc(need_one + need_two + 3);
 114                xp[0] = '"';
 115                quote_c_style(one, xp + 1, NULL, 1);
 116                quote_c_style(two, xp + need_one + 1, NULL, 1);
 117                strcpy(xp + need_one + need_two + 1, "\"");
 118                return xp;
 119        }
 120        need_one = strlen(one);
 121        need_two = strlen(two);
 122        xp = xmalloc(need_one + need_two + 1);
 123        strcpy(xp, one);
 124        strcpy(xp + need_one, two);
 125        return xp;
 126}
 127
 128static const char *external_diff(void)
 129{
 130        static const char *external_diff_cmd = NULL;
 131        static int done_preparing = 0;
 132
 133        if (done_preparing)
 134                return external_diff_cmd;
 135        external_diff_cmd = getenv("GIT_EXTERNAL_DIFF");
 136        done_preparing = 1;
 137        return external_diff_cmd;
 138}
 139
 140#define TEMPFILE_PATH_LEN               50
 141
 142static struct diff_tempfile {
 143        const char *name; /* filename external diff should read from */
 144        char hex[41];
 145        char mode[10];
 146        char tmp_path[TEMPFILE_PATH_LEN];
 147} diff_temp[2];
 148
 149static int count_lines(const char *data, int size)
 150{
 151        int count, ch, completely_empty = 1, nl_just_seen = 0;
 152        count = 0;
 153        while (0 < size--) {
 154                ch = *data++;
 155                if (ch == '\n') {
 156                        count++;
 157                        nl_just_seen = 1;
 158                        completely_empty = 0;
 159                }
 160                else {
 161                        nl_just_seen = 0;
 162                        completely_empty = 0;
 163                }
 164        }
 165        if (completely_empty)
 166                return 0;
 167        if (!nl_just_seen)
 168                count++; /* no trailing newline */
 169        return count;
 170}
 171
 172static void print_line_count(int count)
 173{
 174        switch (count) {
 175        case 0:
 176                printf("0,0");
 177                break;
 178        case 1:
 179                printf("1");
 180                break;
 181        default:
 182                printf("1,%d", count);
 183                break;
 184        }
 185}
 186
 187static void copy_file(int prefix, const char *data, int size,
 188                const char *set, const char *reset)
 189{
 190        int ch, nl_just_seen = 1;
 191        while (0 < size--) {
 192                ch = *data++;
 193                if (nl_just_seen) {
 194                        fputs(set, stdout);
 195                        putchar(prefix);
 196                }
 197                if (ch == '\n') {
 198                        nl_just_seen = 1;
 199                        fputs(reset, stdout);
 200                } else
 201                        nl_just_seen = 0;
 202                putchar(ch);
 203        }
 204        if (!nl_just_seen)
 205                printf("%s\n\\ No newline at end of file\n", reset);
 206}
 207
 208static void emit_rewrite_diff(const char *name_a,
 209                              const char *name_b,
 210                              struct diff_filespec *one,
 211                              struct diff_filespec *two,
 212                              int color_diff)
 213{
 214        int lc_a, lc_b;
 215        const char *name_a_tab, *name_b_tab;
 216        const char *metainfo = diff_get_color(color_diff, DIFF_METAINFO);
 217        const char *fraginfo = diff_get_color(color_diff, DIFF_FRAGINFO);
 218        const char *old = diff_get_color(color_diff, DIFF_FILE_OLD);
 219        const char *new = diff_get_color(color_diff, DIFF_FILE_NEW);
 220        const char *reset = diff_get_color(color_diff, DIFF_RESET);
 221
 222        name_a += (*name_a == '/');
 223        name_b += (*name_b == '/');
 224        name_a_tab = strchr(name_a, ' ') ? "\t" : "";
 225        name_b_tab = strchr(name_b, ' ') ? "\t" : "";
 226
 227        diff_populate_filespec(one, 0);
 228        diff_populate_filespec(two, 0);
 229        lc_a = count_lines(one->data, one->size);
 230        lc_b = count_lines(two->data, two->size);
 231        printf("%s--- a/%s%s%s\n%s+++ b/%s%s%s\n%s@@ -",
 232               metainfo, name_a, name_a_tab, reset,
 233               metainfo, name_b, name_b_tab, reset, fraginfo);
 234        print_line_count(lc_a);
 235        printf(" +");
 236        print_line_count(lc_b);
 237        printf(" @@%s\n", reset);
 238        if (lc_a)
 239                copy_file('-', one->data, one->size, old, reset);
 240        if (lc_b)
 241                copy_file('+', two->data, two->size, new, reset);
 242}
 243
 244static int fill_mmfile(mmfile_t *mf, struct diff_filespec *one)
 245{
 246        if (!DIFF_FILE_VALID(one)) {
 247                mf->ptr = (char *)""; /* does not matter */
 248                mf->size = 0;
 249                return 0;
 250        }
 251        else if (diff_populate_filespec(one, 0))
 252                return -1;
 253        mf->ptr = one->data;
 254        mf->size = one->size;
 255        return 0;
 256}
 257
 258struct diff_words_buffer {
 259        mmfile_t text;
 260        long alloc;
 261        long current; /* output pointer */
 262        int suppressed_newline;
 263};
 264
 265static void diff_words_append(char *line, unsigned long len,
 266                struct diff_words_buffer *buffer)
 267{
 268        if (buffer->text.size + len > buffer->alloc) {
 269                buffer->alloc = (buffer->text.size + len) * 3 / 2;
 270                buffer->text.ptr = xrealloc(buffer->text.ptr, buffer->alloc);
 271        }
 272        line++;
 273        len--;
 274        memcpy(buffer->text.ptr + buffer->text.size, line, len);
 275        buffer->text.size += len;
 276}
 277
 278struct diff_words_data {
 279        struct xdiff_emit_state xm;
 280        struct diff_words_buffer minus, plus;
 281};
 282
 283static void print_word(struct diff_words_buffer *buffer, int len, int color,
 284                int suppress_newline)
 285{
 286        const char *ptr;
 287        int eol = 0;
 288
 289        if (len == 0)
 290                return;
 291
 292        ptr  = buffer->text.ptr + buffer->current;
 293        buffer->current += len;
 294
 295        if (ptr[len - 1] == '\n') {
 296                eol = 1;
 297                len--;
 298        }
 299
 300        fputs(diff_get_color(1, color), stdout);
 301        fwrite(ptr, len, 1, stdout);
 302        fputs(diff_get_color(1, DIFF_RESET), stdout);
 303
 304        if (eol) {
 305                if (suppress_newline)
 306                        buffer->suppressed_newline = 1;
 307                else
 308                        putchar('\n');
 309        }
 310}
 311
 312static void fn_out_diff_words_aux(void *priv, char *line, unsigned long len)
 313{
 314        struct diff_words_data *diff_words = priv;
 315
 316        if (diff_words->minus.suppressed_newline) {
 317                if (line[0] != '+')
 318                        putchar('\n');
 319                diff_words->minus.suppressed_newline = 0;
 320        }
 321
 322        len--;
 323        switch (line[0]) {
 324                case '-':
 325                        print_word(&diff_words->minus, len, DIFF_FILE_OLD, 1);
 326                        break;
 327                case '+':
 328                        print_word(&diff_words->plus, len, DIFF_FILE_NEW, 0);
 329                        break;
 330                case ' ':
 331                        print_word(&diff_words->plus, len, DIFF_PLAIN, 0);
 332                        diff_words->minus.current += len;
 333                        break;
 334        }
 335}
 336
 337/* this executes the word diff on the accumulated buffers */
 338static void diff_words_show(struct diff_words_data *diff_words)
 339{
 340        xpparam_t xpp;
 341        xdemitconf_t xecfg;
 342        xdemitcb_t ecb;
 343        mmfile_t minus, plus;
 344        int i;
 345
 346        minus.size = diff_words->minus.text.size;
 347        minus.ptr = xmalloc(minus.size);
 348        memcpy(minus.ptr, diff_words->minus.text.ptr, minus.size);
 349        for (i = 0; i < minus.size; i++)
 350                if (isspace(minus.ptr[i]))
 351                        minus.ptr[i] = '\n';
 352        diff_words->minus.current = 0;
 353
 354        plus.size = diff_words->plus.text.size;
 355        plus.ptr = xmalloc(plus.size);
 356        memcpy(plus.ptr, diff_words->plus.text.ptr, plus.size);
 357        for (i = 0; i < plus.size; i++)
 358                if (isspace(plus.ptr[i]))
 359                        plus.ptr[i] = '\n';
 360        diff_words->plus.current = 0;
 361
 362        xpp.flags = XDF_NEED_MINIMAL;
 363        xecfg.ctxlen = diff_words->minus.alloc + diff_words->plus.alloc;
 364        xecfg.flags = 0;
 365        ecb.outf = xdiff_outf;
 366        ecb.priv = diff_words;
 367        diff_words->xm.consume = fn_out_diff_words_aux;
 368        xdl_diff(&minus, &plus, &xpp, &xecfg, &ecb);
 369
 370        free(minus.ptr);
 371        free(plus.ptr);
 372        diff_words->minus.text.size = diff_words->plus.text.size = 0;
 373
 374        if (diff_words->minus.suppressed_newline) {
 375                putchar('\n');
 376                diff_words->minus.suppressed_newline = 0;
 377        }
 378}
 379
 380struct emit_callback {
 381        struct xdiff_emit_state xm;
 382        int nparents, color_diff;
 383        const char **label_path;
 384        struct diff_words_data *diff_words;
 385        int *found_changesp;
 386};
 387
 388static void free_diff_words_data(struct emit_callback *ecbdata)
 389{
 390        if (ecbdata->diff_words) {
 391                /* flush buffers */
 392                if (ecbdata->diff_words->minus.text.size ||
 393                                ecbdata->diff_words->plus.text.size)
 394                        diff_words_show(ecbdata->diff_words);
 395
 396                if (ecbdata->diff_words->minus.text.ptr)
 397                        free (ecbdata->diff_words->minus.text.ptr);
 398                if (ecbdata->diff_words->plus.text.ptr)
 399                        free (ecbdata->diff_words->plus.text.ptr);
 400                free(ecbdata->diff_words);
 401                ecbdata->diff_words = NULL;
 402        }
 403}
 404
 405const char *diff_get_color(int diff_use_color, enum color_diff ix)
 406{
 407        if (diff_use_color)
 408                return diff_colors[ix];
 409        return "";
 410}
 411
 412static void emit_line(const char *set, const char *reset, const char *line, int len)
 413{
 414        if (len > 0 && line[len-1] == '\n')
 415                len--;
 416        fputs(set, stdout);
 417        fwrite(line, len, 1, stdout);
 418        puts(reset);
 419}
 420
 421static void emit_line_with_ws(int nparents,
 422                const char *set, const char *reset, const char *ws,
 423                const char *line, int len)
 424{
 425        int col0 = nparents;
 426        int last_tab_in_indent = -1;
 427        int last_space_in_indent = -1;
 428        int i;
 429        int tail = len;
 430        int need_highlight_leading_space = 0;
 431        /* The line is a newly added line.  Does it have funny leading
 432         * whitespaces?  In indent, SP should never precede a TAB.
 433         */
 434        for (i = col0; i < len; i++) {
 435                if (line[i] == '\t') {
 436                        last_tab_in_indent = i;
 437                        if (0 <= last_space_in_indent)
 438                                need_highlight_leading_space = 1;
 439                }
 440                else if (line[i] == ' ')
 441                        last_space_in_indent = i;
 442                else
 443                        break;
 444        }
 445        fputs(set, stdout);
 446        fwrite(line, col0, 1, stdout);
 447        fputs(reset, stdout);
 448        if (((i == len) || line[i] == '\n') && i != col0) {
 449                /* The whole line was indent */
 450                emit_line(ws, reset, line + col0, len - col0);
 451                return;
 452        }
 453        i = col0;
 454        if (need_highlight_leading_space) {
 455                while (i < last_tab_in_indent) {
 456                        if (line[i] == ' ') {
 457                                fputs(ws, stdout);
 458                                putchar(' ');
 459                                fputs(reset, stdout);
 460                        }
 461                        else
 462                                putchar(line[i]);
 463                        i++;
 464                }
 465        }
 466        tail = len - 1;
 467        if (line[tail] == '\n' && i < tail)
 468                tail--;
 469        while (i < tail) {
 470                if (!isspace(line[tail]))
 471                        break;
 472                tail--;
 473        }
 474        if ((i < tail && line[tail + 1] != '\n')) {
 475                /* This has whitespace between tail+1..len */
 476                fputs(set, stdout);
 477                fwrite(line + i, tail - i + 1, 1, stdout);
 478                fputs(reset, stdout);
 479                emit_line(ws, reset, line + tail + 1, len - tail - 1);
 480        }
 481        else
 482                emit_line(set, reset, line + i, len - i);
 483}
 484
 485static void emit_add_line(const char *reset, struct emit_callback *ecbdata, const char *line, int len)
 486{
 487        const char *ws = diff_get_color(ecbdata->color_diff, DIFF_WHITESPACE);
 488        const char *set = diff_get_color(ecbdata->color_diff, DIFF_FILE_NEW);
 489
 490        if (!*ws)
 491                emit_line(set, reset, line, len);
 492        else
 493                emit_line_with_ws(ecbdata->nparents, set, reset, ws,
 494                                line, len);
 495}
 496
 497static void fn_out_consume(void *priv, char *line, unsigned long len)
 498{
 499        int i;
 500        int color;
 501        struct emit_callback *ecbdata = priv;
 502        const char *set = diff_get_color(ecbdata->color_diff, DIFF_METAINFO);
 503        const char *reset = diff_get_color(ecbdata->color_diff, DIFF_RESET);
 504
 505        *(ecbdata->found_changesp) = 1;
 506
 507        if (ecbdata->label_path[0]) {
 508                const char *name_a_tab, *name_b_tab;
 509
 510                name_a_tab = strchr(ecbdata->label_path[0], ' ') ? "\t" : "";
 511                name_b_tab = strchr(ecbdata->label_path[1], ' ') ? "\t" : "";
 512
 513                printf("%s--- %s%s%s\n",
 514                       set, ecbdata->label_path[0], reset, name_a_tab);
 515                printf("%s+++ %s%s%s\n",
 516                       set, ecbdata->label_path[1], reset, name_b_tab);
 517                ecbdata->label_path[0] = ecbdata->label_path[1] = NULL;
 518        }
 519
 520        /* This is not really necessary for now because
 521         * this codepath only deals with two-way diffs.
 522         */
 523        for (i = 0; i < len && line[i] == '@'; i++)
 524                ;
 525        if (2 <= i && i < len && line[i] == ' ') {
 526                ecbdata->nparents = i - 1;
 527                emit_line(diff_get_color(ecbdata->color_diff, DIFF_FRAGINFO),
 528                          reset, line, len);
 529                return;
 530        }
 531
 532        if (len < ecbdata->nparents) {
 533                set = reset;
 534                emit_line(reset, reset, line, len);
 535                return;
 536        }
 537
 538        color = DIFF_PLAIN;
 539        if (ecbdata->diff_words && ecbdata->nparents != 1)
 540                /* fall back to normal diff */
 541                free_diff_words_data(ecbdata);
 542        if (ecbdata->diff_words) {
 543                if (line[0] == '-') {
 544                        diff_words_append(line, len,
 545                                          &ecbdata->diff_words->minus);
 546                        return;
 547                } else if (line[0] == '+') {
 548                        diff_words_append(line, len,
 549                                          &ecbdata->diff_words->plus);
 550                        return;
 551                }
 552                if (ecbdata->diff_words->minus.text.size ||
 553                    ecbdata->diff_words->plus.text.size)
 554                        diff_words_show(ecbdata->diff_words);
 555                line++;
 556                len--;
 557                emit_line(set, reset, line, len);
 558                return;
 559        }
 560        for (i = 0; i < ecbdata->nparents && len; i++) {
 561                if (line[i] == '-')
 562                        color = DIFF_FILE_OLD;
 563                else if (line[i] == '+')
 564                        color = DIFF_FILE_NEW;
 565        }
 566
 567        if (color != DIFF_FILE_NEW) {
 568                emit_line(diff_get_color(ecbdata->color_diff, color),
 569                          reset, line, len);
 570                return;
 571        }
 572        emit_add_line(reset, ecbdata, line, len);
 573}
 574
 575static char *pprint_rename(const char *a, const char *b)
 576{
 577        const char *old = a;
 578        const char *new = b;
 579        char *name = NULL;
 580        int pfx_length, sfx_length;
 581        int len_a = strlen(a);
 582        int len_b = strlen(b);
 583        int qlen_a = quote_c_style(a, NULL, NULL, 0);
 584        int qlen_b = quote_c_style(b, NULL, NULL, 0);
 585
 586        if (qlen_a || qlen_b) {
 587                if (qlen_a) len_a = qlen_a;
 588                if (qlen_b) len_b = qlen_b;
 589                name = xmalloc( len_a + len_b + 5 );
 590                if (qlen_a)
 591                        quote_c_style(a, name, NULL, 0);
 592                else
 593                        memcpy(name, a, len_a);
 594                memcpy(name + len_a, " => ", 4);
 595                if (qlen_b)
 596                        quote_c_style(b, name + len_a + 4, NULL, 0);
 597                else
 598                        memcpy(name + len_a + 4, b, len_b + 1);
 599                return name;
 600        }
 601
 602        /* Find common prefix */
 603        pfx_length = 0;
 604        while (*old && *new && *old == *new) {
 605                if (*old == '/')
 606                        pfx_length = old - a + 1;
 607                old++;
 608                new++;
 609        }
 610
 611        /* Find common suffix */
 612        old = a + len_a;
 613        new = b + len_b;
 614        sfx_length = 0;
 615        while (a <= old && b <= new && *old == *new) {
 616                if (*old == '/')
 617                        sfx_length = len_a - (old - a);
 618                old--;
 619                new--;
 620        }
 621
 622        /*
 623         * pfx{mid-a => mid-b}sfx
 624         * {pfx-a => pfx-b}sfx
 625         * pfx{sfx-a => sfx-b}
 626         * name-a => name-b
 627         */
 628        if (pfx_length + sfx_length) {
 629                int a_midlen = len_a - pfx_length - sfx_length;
 630                int b_midlen = len_b - pfx_length - sfx_length;
 631                if (a_midlen < 0) a_midlen = 0;
 632                if (b_midlen < 0) b_midlen = 0;
 633
 634                name = xmalloc(pfx_length + a_midlen + b_midlen + sfx_length + 7);
 635                sprintf(name, "%.*s{%.*s => %.*s}%s",
 636                        pfx_length, a,
 637                        a_midlen, a + pfx_length,
 638                        b_midlen, b + pfx_length,
 639                        a + len_a - sfx_length);
 640        }
 641        else {
 642                name = xmalloc(len_a + len_b + 5);
 643                sprintf(name, "%s => %s", a, b);
 644        }
 645        return name;
 646}
 647
 648struct diffstat_t {
 649        struct xdiff_emit_state xm;
 650
 651        int nr;
 652        int alloc;
 653        struct diffstat_file {
 654                char *name;
 655                unsigned is_unmerged:1;
 656                unsigned is_binary:1;
 657                unsigned is_renamed:1;
 658                unsigned int added, deleted;
 659        } **files;
 660};
 661
 662static struct diffstat_file *diffstat_add(struct diffstat_t *diffstat,
 663                                          const char *name_a,
 664                                          const char *name_b)
 665{
 666        struct diffstat_file *x;
 667        x = xcalloc(sizeof (*x), 1);
 668        if (diffstat->nr == diffstat->alloc) {
 669                diffstat->alloc = alloc_nr(diffstat->alloc);
 670                diffstat->files = xrealloc(diffstat->files,
 671                                diffstat->alloc * sizeof(x));
 672        }
 673        diffstat->files[diffstat->nr++] = x;
 674        if (name_b) {
 675                x->name = pprint_rename(name_a, name_b);
 676                x->is_renamed = 1;
 677        }
 678        else
 679                x->name = xstrdup(name_a);
 680        return x;
 681}
 682
 683static void diffstat_consume(void *priv, char *line, unsigned long len)
 684{
 685        struct diffstat_t *diffstat = priv;
 686        struct diffstat_file *x = diffstat->files[diffstat->nr - 1];
 687
 688        if (line[0] == '+')
 689                x->added++;
 690        else if (line[0] == '-')
 691                x->deleted++;
 692}
 693
 694const char mime_boundary_leader[] = "------------";
 695
 696static int scale_linear(int it, int width, int max_change)
 697{
 698        /*
 699         * make sure that at least one '-' is printed if there were deletions,
 700         * and likewise for '+'.
 701         */
 702        if (max_change < 2)
 703                return it;
 704        return ((it - 1) * (width - 1) + max_change - 1) / (max_change - 1);
 705}
 706
 707static void show_name(const char *prefix, const char *name, int len,
 708                      const char *reset, const char *set)
 709{
 710        printf(" %s%s%-*s%s |", set, prefix, len, name, reset);
 711}
 712
 713static void show_graph(char ch, int cnt, const char *set, const char *reset)
 714{
 715        if (cnt <= 0)
 716                return;
 717        printf("%s", set);
 718        while (cnt--)
 719                putchar(ch);
 720        printf("%s", reset);
 721}
 722
 723static void show_stats(struct diffstat_t* data, struct diff_options *options)
 724{
 725        int i, len, add, del, total, adds = 0, dels = 0;
 726        int max_change = 0, max_len = 0;
 727        int total_files = data->nr;
 728        int width, name_width;
 729        const char *reset, *set, *add_c, *del_c;
 730
 731        if (data->nr == 0)
 732                return;
 733
 734        width = options->stat_width ? options->stat_width : 80;
 735        name_width = options->stat_name_width ? options->stat_name_width : 50;
 736
 737        /* Sanity: give at least 5 columns to the graph,
 738         * but leave at least 10 columns for the name.
 739         */
 740        if (width < name_width + 15) {
 741                if (name_width <= 25)
 742                        width = name_width + 15;
 743                else
 744                        name_width = width - 15;
 745        }
 746
 747        /* Find the longest filename and max number of changes */
 748        reset = diff_get_color(options->color_diff, DIFF_RESET);
 749        set = diff_get_color(options->color_diff, DIFF_PLAIN);
 750        add_c = diff_get_color(options->color_diff, DIFF_FILE_NEW);
 751        del_c = diff_get_color(options->color_diff, DIFF_FILE_OLD);
 752
 753        for (i = 0; i < data->nr; i++) {
 754                struct diffstat_file *file = data->files[i];
 755                int change = file->added + file->deleted;
 756
 757                if (!file->is_renamed) {  /* renames are already quoted by pprint_rename */
 758                        len = quote_c_style(file->name, NULL, NULL, 0);
 759                        if (len) {
 760                                char *qname = xmalloc(len + 1);
 761                                quote_c_style(file->name, qname, NULL, 0);
 762                                free(file->name);
 763                                file->name = qname;
 764                        }
 765                }
 766
 767                len = strlen(file->name);
 768                if (max_len < len)
 769                        max_len = len;
 770
 771                if (file->is_binary || file->is_unmerged)
 772                        continue;
 773                if (max_change < change)
 774                        max_change = change;
 775        }
 776
 777        /* Compute the width of the graph part;
 778         * 10 is for one blank at the beginning of the line plus
 779         * " | count " between the name and the graph.
 780         *
 781         * From here on, name_width is the width of the name area,
 782         * and width is the width of the graph area.
 783         */
 784        name_width = (name_width < max_len) ? name_width : max_len;
 785        if (width < (name_width + 10) + max_change)
 786                width = width - (name_width + 10);
 787        else
 788                width = max_change;
 789
 790        for (i = 0; i < data->nr; i++) {
 791                const char *prefix = "";
 792                char *name = data->files[i]->name;
 793                int added = data->files[i]->added;
 794                int deleted = data->files[i]->deleted;
 795                int name_len;
 796
 797                /*
 798                 * "scale" the filename
 799                 */
 800                len = name_width;
 801                name_len = strlen(name);
 802                if (name_width < name_len) {
 803                        char *slash;
 804                        prefix = "...";
 805                        len -= 3;
 806                        name += name_len - len;
 807                        slash = strchr(name, '/');
 808                        if (slash)
 809                                name = slash;
 810                }
 811
 812                if (data->files[i]->is_binary) {
 813                        show_name(prefix, name, len, reset, set);
 814                        printf("  Bin\n");
 815                        goto free_diffstat_file;
 816                }
 817                else if (data->files[i]->is_unmerged) {
 818                        show_name(prefix, name, len, reset, set);
 819                        printf("  Unmerged\n");
 820                        goto free_diffstat_file;
 821                }
 822                else if (!data->files[i]->is_renamed &&
 823                         (added + deleted == 0)) {
 824                        total_files--;
 825                        goto free_diffstat_file;
 826                }
 827
 828                /*
 829                 * scale the add/delete
 830                 */
 831                add = added;
 832                del = deleted;
 833                total = add + del;
 834                adds += add;
 835                dels += del;
 836
 837                if (width <= max_change) {
 838                        add = scale_linear(add, width, max_change);
 839                        del = scale_linear(del, width, max_change);
 840                        total = add + del;
 841                }
 842                show_name(prefix, name, len, reset, set);
 843                printf("%5d ", added + deleted);
 844                show_graph('+', add, add_c, reset);
 845                show_graph('-', del, del_c, reset);
 846                putchar('\n');
 847        free_diffstat_file:
 848                free(data->files[i]->name);
 849                free(data->files[i]);
 850        }
 851        free(data->files);
 852        printf("%s %d files changed, %d insertions(+), %d deletions(-)%s\n",
 853               set, total_files, adds, dels, reset);
 854}
 855
 856static void show_shortstats(struct diffstat_t* data)
 857{
 858        int i, adds = 0, dels = 0, total_files = data->nr;
 859
 860        if (data->nr == 0)
 861                return;
 862
 863        for (i = 0; i < data->nr; i++) {
 864                if (!data->files[i]->is_binary &&
 865                    !data->files[i]->is_unmerged) {
 866                        int added = data->files[i]->added;
 867                        int deleted= data->files[i]->deleted;
 868                        if (!data->files[i]->is_renamed &&
 869                            (added + deleted == 0)) {
 870                                total_files--;
 871                        } else {
 872                                adds += added;
 873                                dels += deleted;
 874                        }
 875                }
 876                free(data->files[i]->name);
 877                free(data->files[i]);
 878        }
 879        free(data->files);
 880
 881        printf(" %d files changed, %d insertions(+), %d deletions(-)\n",
 882               total_files, adds, dels);
 883}
 884
 885static void show_numstat(struct diffstat_t* data, struct diff_options *options)
 886{
 887        int i;
 888
 889        for (i = 0; i < data->nr; i++) {
 890                struct diffstat_file *file = data->files[i];
 891
 892                if (file->is_binary)
 893                        printf("-\t-\t");
 894                else
 895                        printf("%d\t%d\t", file->added, file->deleted);
 896                if (options->line_termination && !file->is_renamed &&
 897                    quote_c_style(file->name, NULL, NULL, 0))
 898                        quote_c_style(file->name, NULL, stdout, 0);
 899                else
 900                        fputs(file->name, stdout);
 901                putchar(options->line_termination);
 902        }
 903}
 904
 905struct checkdiff_t {
 906        struct xdiff_emit_state xm;
 907        const char *filename;
 908        int lineno, color_diff;
 909};
 910
 911static void checkdiff_consume(void *priv, char *line, unsigned long len)
 912{
 913        struct checkdiff_t *data = priv;
 914        const char *ws = diff_get_color(data->color_diff, DIFF_WHITESPACE);
 915        const char *reset = diff_get_color(data->color_diff, DIFF_RESET);
 916        const char *set = diff_get_color(data->color_diff, DIFF_FILE_NEW);
 917
 918        if (line[0] == '+') {
 919                int i, spaces = 0, space_before_tab = 0, white_space_at_end = 0;
 920
 921                /* check space before tab */
 922                for (i = 1; i < len && (line[i] == ' ' || line[i] == '\t'); i++)
 923                        if (line[i] == ' ')
 924                                spaces++;
 925                if (line[i - 1] == '\t' && spaces)
 926                        space_before_tab = 1;
 927
 928                /* check white space at line end */
 929                if (line[len - 1] == '\n')
 930                        len--;
 931                if (isspace(line[len - 1]))
 932                        white_space_at_end = 1;
 933
 934                if (space_before_tab || white_space_at_end) {
 935                        printf("%s:%d: %s", data->filename, data->lineno, ws);
 936                        if (space_before_tab) {
 937                                printf("space before tab");
 938                                if (white_space_at_end)
 939                                        putchar(',');
 940                        }
 941                        if (white_space_at_end)
 942                                printf("white space at end");
 943                        printf(":%s ", reset);
 944                        emit_line_with_ws(1, set, reset, ws, line, len);
 945                }
 946
 947                data->lineno++;
 948        } else if (line[0] == ' ')
 949                data->lineno++;
 950        else if (line[0] == '@') {
 951                char *plus = strchr(line, '+');
 952                if (plus)
 953                        data->lineno = strtol(plus, NULL, 10);
 954                else
 955                        die("invalid diff");
 956        }
 957}
 958
 959static unsigned char *deflate_it(char *data,
 960                                 unsigned long size,
 961                                 unsigned long *result_size)
 962{
 963        int bound;
 964        unsigned char *deflated;
 965        z_stream stream;
 966
 967        memset(&stream, 0, sizeof(stream));
 968        deflateInit(&stream, zlib_compression_level);
 969        bound = deflateBound(&stream, size);
 970        deflated = xmalloc(bound);
 971        stream.next_out = deflated;
 972        stream.avail_out = bound;
 973
 974        stream.next_in = (unsigned char *)data;
 975        stream.avail_in = size;
 976        while (deflate(&stream, Z_FINISH) == Z_OK)
 977                ; /* nothing */
 978        deflateEnd(&stream);
 979        *result_size = stream.total_out;
 980        return deflated;
 981}
 982
 983static void emit_binary_diff_body(mmfile_t *one, mmfile_t *two)
 984{
 985        void *cp;
 986        void *delta;
 987        void *deflated;
 988        void *data;
 989        unsigned long orig_size;
 990        unsigned long delta_size;
 991        unsigned long deflate_size;
 992        unsigned long data_size;
 993
 994        /* We could do deflated delta, or we could do just deflated two,
 995         * whichever is smaller.
 996         */
 997        delta = NULL;
 998        deflated = deflate_it(two->ptr, two->size, &deflate_size);
 999        if (one->size && two->size) {
1000                delta = diff_delta(one->ptr, one->size,
1001                                   two->ptr, two->size,
1002                                   &delta_size, deflate_size);
1003                if (delta) {
1004                        void *to_free = delta;
1005                        orig_size = delta_size;
1006                        delta = deflate_it(delta, delta_size, &delta_size);
1007                        free(to_free);
1008                }
1009        }
1010
1011        if (delta && delta_size < deflate_size) {
1012                printf("delta %lu\n", orig_size);
1013                free(deflated);
1014                data = delta;
1015                data_size = delta_size;
1016        }
1017        else {
1018                printf("literal %lu\n", two->size);
1019                free(delta);
1020                data = deflated;
1021                data_size = deflate_size;
1022        }
1023
1024        /* emit data encoded in base85 */
1025        cp = data;
1026        while (data_size) {
1027                int bytes = (52 < data_size) ? 52 : data_size;
1028                char line[70];
1029                data_size -= bytes;
1030                if (bytes <= 26)
1031                        line[0] = bytes + 'A' - 1;
1032                else
1033                        line[0] = bytes - 26 + 'a' - 1;
1034                encode_85(line + 1, cp, bytes);
1035                cp = (char *) cp + bytes;
1036                puts(line);
1037        }
1038        printf("\n");
1039        free(data);
1040}
1041
1042static void emit_binary_diff(mmfile_t *one, mmfile_t *two)
1043{
1044        printf("GIT binary patch\n");
1045        emit_binary_diff_body(one, two);
1046        emit_binary_diff_body(two, one);
1047}
1048
1049#define FIRST_FEW_BYTES 8000
1050static int mmfile_is_binary(mmfile_t *mf)
1051{
1052        long sz = mf->size;
1053        if (FIRST_FEW_BYTES < sz)
1054                sz = FIRST_FEW_BYTES;
1055        return !!memchr(mf->ptr, 0, sz);
1056}
1057
1058static void builtin_diff(const char *name_a,
1059                         const char *name_b,
1060                         struct diff_filespec *one,
1061                         struct diff_filespec *two,
1062                         const char *xfrm_msg,
1063                         struct diff_options *o,
1064                         int complete_rewrite)
1065{
1066        mmfile_t mf1, mf2;
1067        const char *lbl[2];
1068        char *a_one, *b_two;
1069        const char *set = diff_get_color(o->color_diff, DIFF_METAINFO);
1070        const char *reset = diff_get_color(o->color_diff, DIFF_RESET);
1071
1072        a_one = quote_two("a/", name_a + (*name_a == '/'));
1073        b_two = quote_two("b/", name_b + (*name_b == '/'));
1074        lbl[0] = DIFF_FILE_VALID(one) ? a_one : "/dev/null";
1075        lbl[1] = DIFF_FILE_VALID(two) ? b_two : "/dev/null";
1076        printf("%sdiff --git %s %s%s\n", set, a_one, b_two, reset);
1077        if (lbl[0][0] == '/') {
1078                /* /dev/null */
1079                printf("%snew file mode %06o%s\n", set, two->mode, reset);
1080                if (xfrm_msg && xfrm_msg[0])
1081                        printf("%s%s%s\n", set, xfrm_msg, reset);
1082        }
1083        else if (lbl[1][0] == '/') {
1084                printf("%sdeleted file mode %06o%s\n", set, one->mode, reset);
1085                if (xfrm_msg && xfrm_msg[0])
1086                        printf("%s%s%s\n", set, xfrm_msg, reset);
1087        }
1088        else {
1089                if (one->mode != two->mode) {
1090                        printf("%sold mode %06o%s\n", set, one->mode, reset);
1091                        printf("%snew mode %06o%s\n", set, two->mode, reset);
1092                }
1093                if (xfrm_msg && xfrm_msg[0])
1094                        printf("%s%s%s\n", set, xfrm_msg, reset);
1095                /*
1096                 * we do not run diff between different kind
1097                 * of objects.
1098                 */
1099                if ((one->mode ^ two->mode) & S_IFMT)
1100                        goto free_ab_and_return;
1101                if (complete_rewrite) {
1102                        emit_rewrite_diff(name_a, name_b, one, two,
1103                                        o->color_diff);
1104                        o->found_changes = 1;
1105                        goto free_ab_and_return;
1106                }
1107        }
1108
1109        if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
1110                die("unable to read files to diff");
1111
1112        if (!o->text && (mmfile_is_binary(&mf1) || mmfile_is_binary(&mf2))) {
1113                /* Quite common confusing case */
1114                if (mf1.size == mf2.size &&
1115                    !memcmp(mf1.ptr, mf2.ptr, mf1.size))
1116                        goto free_ab_and_return;
1117                if (o->binary)
1118                        emit_binary_diff(&mf1, &mf2);
1119                else
1120                        printf("Binary files %s and %s differ\n",
1121                               lbl[0], lbl[1]);
1122                o->found_changes = 1;
1123        }
1124        else {
1125                /* Crazy xdl interfaces.. */
1126                const char *diffopts = getenv("GIT_DIFF_OPTS");
1127                xpparam_t xpp;
1128                xdemitconf_t xecfg;
1129                xdemitcb_t ecb;
1130                struct emit_callback ecbdata;
1131
1132                memset(&ecbdata, 0, sizeof(ecbdata));
1133                ecbdata.label_path = lbl;
1134                ecbdata.color_diff = o->color_diff;
1135                ecbdata.found_changesp = &o->found_changes;
1136                xpp.flags = XDF_NEED_MINIMAL | o->xdl_opts;
1137                xecfg.ctxlen = o->context;
1138                xecfg.flags = XDL_EMIT_FUNCNAMES;
1139                if (!diffopts)
1140                        ;
1141                else if (!prefixcmp(diffopts, "--unified="))
1142                        xecfg.ctxlen = strtoul(diffopts + 10, NULL, 10);
1143                else if (!prefixcmp(diffopts, "-u"))
1144                        xecfg.ctxlen = strtoul(diffopts + 2, NULL, 10);
1145                ecb.outf = xdiff_outf;
1146                ecb.priv = &ecbdata;
1147                ecbdata.xm.consume = fn_out_consume;
1148                if (o->color_diff_words)
1149                        ecbdata.diff_words =
1150                                xcalloc(1, sizeof(struct diff_words_data));
1151                xdl_diff(&mf1, &mf2, &xpp, &xecfg, &ecb);
1152                if (o->color_diff_words)
1153                        free_diff_words_data(&ecbdata);
1154        }
1155
1156 free_ab_and_return:
1157        free(a_one);
1158        free(b_two);
1159        return;
1160}
1161
1162static void builtin_diffstat(const char *name_a, const char *name_b,
1163                             struct diff_filespec *one,
1164                             struct diff_filespec *two,
1165                             struct diffstat_t *diffstat,
1166                             struct diff_options *o,
1167                             int complete_rewrite)
1168{
1169        mmfile_t mf1, mf2;
1170        struct diffstat_file *data;
1171
1172        data = diffstat_add(diffstat, name_a, name_b);
1173
1174        if (!one || !two) {
1175                data->is_unmerged = 1;
1176                return;
1177        }
1178        if (complete_rewrite) {
1179                diff_populate_filespec(one, 0);
1180                diff_populate_filespec(two, 0);
1181                data->deleted = count_lines(one->data, one->size);
1182                data->added = count_lines(two->data, two->size);
1183                return;
1184        }
1185        if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
1186                die("unable to read files to diff");
1187
1188        if (mmfile_is_binary(&mf1) || mmfile_is_binary(&mf2))
1189                data->is_binary = 1;
1190        else {
1191                /* Crazy xdl interfaces.. */
1192                xpparam_t xpp;
1193                xdemitconf_t xecfg;
1194                xdemitcb_t ecb;
1195
1196                xpp.flags = XDF_NEED_MINIMAL | o->xdl_opts;
1197                xecfg.ctxlen = 0;
1198                xecfg.flags = 0;
1199                ecb.outf = xdiff_outf;
1200                ecb.priv = diffstat;
1201                xdl_diff(&mf1, &mf2, &xpp, &xecfg, &ecb);
1202        }
1203}
1204
1205static void builtin_checkdiff(const char *name_a, const char *name_b,
1206                             struct diff_filespec *one,
1207                             struct diff_filespec *two, struct diff_options *o)
1208{
1209        mmfile_t mf1, mf2;
1210        struct checkdiff_t data;
1211
1212        if (!two)
1213                return;
1214
1215        memset(&data, 0, sizeof(data));
1216        data.xm.consume = checkdiff_consume;
1217        data.filename = name_b ? name_b : name_a;
1218        data.lineno = 0;
1219        data.color_diff = o->color_diff;
1220
1221        if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
1222                die("unable to read files to diff");
1223
1224        if (mmfile_is_binary(&mf2))
1225                return;
1226        else {
1227                /* Crazy xdl interfaces.. */
1228                xpparam_t xpp;
1229                xdemitconf_t xecfg;
1230                xdemitcb_t ecb;
1231
1232                xpp.flags = XDF_NEED_MINIMAL;
1233                xecfg.ctxlen = 0;
1234                xecfg.flags = 0;
1235                ecb.outf = xdiff_outf;
1236                ecb.priv = &data;
1237                xdl_diff(&mf1, &mf2, &xpp, &xecfg, &ecb);
1238        }
1239}
1240
1241struct diff_filespec *alloc_filespec(const char *path)
1242{
1243        int namelen = strlen(path);
1244        struct diff_filespec *spec = xmalloc(sizeof(*spec) + namelen + 1);
1245
1246        memset(spec, 0, sizeof(*spec));
1247        spec->path = (char *)(spec + 1);
1248        memcpy(spec->path, path, namelen+1);
1249        return spec;
1250}
1251
1252void fill_filespec(struct diff_filespec *spec, const unsigned char *sha1,
1253                   unsigned short mode)
1254{
1255        if (mode) {
1256                spec->mode = canon_mode(mode);
1257                hashcpy(spec->sha1, sha1);
1258                spec->sha1_valid = !is_null_sha1(sha1);
1259        }
1260}
1261
1262/*
1263 * Given a name and sha1 pair, if the dircache tells us the file in
1264 * the work tree has that object contents, return true, so that
1265 * prepare_temp_file() does not have to inflate and extract.
1266 */
1267static int reuse_worktree_file(const char *name, const unsigned char *sha1, int want_file)
1268{
1269        struct cache_entry *ce;
1270        struct stat st;
1271        int pos, len;
1272
1273        /* We do not read the cache ourselves here, because the
1274         * benchmark with my previous version that always reads cache
1275         * shows that it makes things worse for diff-tree comparing
1276         * two linux-2.6 kernel trees in an already checked out work
1277         * tree.  This is because most diff-tree comparisons deal with
1278         * only a small number of files, while reading the cache is
1279         * expensive for a large project, and its cost outweighs the
1280         * savings we get by not inflating the object to a temporary
1281         * file.  Practically, this code only helps when we are used
1282         * by diff-cache --cached, which does read the cache before
1283         * calling us.
1284         */
1285        if (!active_cache)
1286                return 0;
1287
1288        /* We want to avoid the working directory if our caller
1289         * doesn't need the data in a normal file, this system
1290         * is rather slow with its stat/open/mmap/close syscalls,
1291         * and the object is contained in a pack file.  The pack
1292         * is probably already open and will be faster to obtain
1293         * the data through than the working directory.  Loose
1294         * objects however would tend to be slower as they need
1295         * to be individually opened and inflated.
1296         */
1297        if (!FAST_WORKING_DIRECTORY && !want_file && has_sha1_pack(sha1, NULL))
1298                return 0;
1299
1300        len = strlen(name);
1301        pos = cache_name_pos(name, len);
1302        if (pos < 0)
1303                return 0;
1304        ce = active_cache[pos];
1305        if ((lstat(name, &st) < 0) ||
1306            !S_ISREG(st.st_mode) || /* careful! */
1307            ce_match_stat(ce, &st, 0) ||
1308            hashcmp(sha1, ce->sha1))
1309                return 0;
1310        /* we return 1 only when we can stat, it is a regular file,
1311         * stat information matches, and sha1 recorded in the cache
1312         * matches.  I.e. we know the file in the work tree really is
1313         * the same as the <name, sha1> pair.
1314         */
1315        return 1;
1316}
1317
1318static struct sha1_size_cache {
1319        unsigned char sha1[20];
1320        unsigned long size;
1321} **sha1_size_cache;
1322static int sha1_size_cache_nr, sha1_size_cache_alloc;
1323
1324static struct sha1_size_cache *locate_size_cache(unsigned char *sha1,
1325                                                 int find_only,
1326                                                 unsigned long size)
1327{
1328        int first, last;
1329        struct sha1_size_cache *e;
1330
1331        first = 0;
1332        last = sha1_size_cache_nr;
1333        while (last > first) {
1334                int cmp, next = (last + first) >> 1;
1335                e = sha1_size_cache[next];
1336                cmp = hashcmp(e->sha1, sha1);
1337                if (!cmp)
1338                        return e;
1339                if (cmp < 0) {
1340                        last = next;
1341                        continue;
1342                }
1343                first = next+1;
1344        }
1345        /* not found */
1346        if (find_only)
1347                return NULL;
1348        /* insert to make it at "first" */
1349        if (sha1_size_cache_alloc <= sha1_size_cache_nr) {
1350                sha1_size_cache_alloc = alloc_nr(sha1_size_cache_alloc);
1351                sha1_size_cache = xrealloc(sha1_size_cache,
1352                                           sha1_size_cache_alloc *
1353                                           sizeof(*sha1_size_cache));
1354        }
1355        sha1_size_cache_nr++;
1356        if (first < sha1_size_cache_nr)
1357                memmove(sha1_size_cache + first + 1, sha1_size_cache + first,
1358                        (sha1_size_cache_nr - first - 1) *
1359                        sizeof(*sha1_size_cache));
1360        e = xmalloc(sizeof(struct sha1_size_cache));
1361        sha1_size_cache[first] = e;
1362        hashcpy(e->sha1, sha1);
1363        e->size = size;
1364        return e;
1365}
1366
1367/*
1368 * While doing rename detection and pickaxe operation, we may need to
1369 * grab the data for the blob (or file) for our own in-core comparison.
1370 * diff_filespec has data and size fields for this purpose.
1371 */
1372int diff_populate_filespec(struct diff_filespec *s, int size_only)
1373{
1374        int err = 0;
1375        if (!DIFF_FILE_VALID(s))
1376                die("internal error: asking to populate invalid file.");
1377        if (S_ISDIR(s->mode))
1378                return -1;
1379
1380        if (!use_size_cache)
1381                size_only = 0;
1382
1383        if (s->data)
1384                return err;
1385        if (!s->sha1_valid ||
1386            reuse_worktree_file(s->path, s->sha1, 0)) {
1387                struct stat st;
1388                int fd;
1389                char *buf;
1390                unsigned long size;
1391
1392                if (lstat(s->path, &st) < 0) {
1393                        if (errno == ENOENT) {
1394                        err_empty:
1395                                err = -1;
1396                        empty:
1397                                s->data = (char *)"";
1398                                s->size = 0;
1399                                return err;
1400                        }
1401                }
1402                s->size = xsize_t(st.st_size);
1403                if (!s->size)
1404                        goto empty;
1405                if (size_only)
1406                        return 0;
1407                if (S_ISLNK(st.st_mode)) {
1408                        int ret;
1409                        s->data = xmalloc(s->size);
1410                        s->should_free = 1;
1411                        ret = readlink(s->path, s->data, s->size);
1412                        if (ret < 0) {
1413                                free(s->data);
1414                                goto err_empty;
1415                        }
1416                        return 0;
1417                }
1418                fd = open(s->path, O_RDONLY);
1419                if (fd < 0)
1420                        goto err_empty;
1421                s->data = xmmap(NULL, s->size, PROT_READ, MAP_PRIVATE, fd, 0);
1422                close(fd);
1423                s->should_munmap = 1;
1424
1425                /*
1426                 * Convert from working tree format to canonical git format
1427                 */
1428                buf = s->data;
1429                size = s->size;
1430                if (convert_to_git(s->path, &buf, &size)) {
1431                        munmap(s->data, s->size);
1432                        s->should_munmap = 0;
1433                        s->data = buf;
1434                        s->size = size;
1435                        s->should_free = 1;
1436                }
1437        }
1438        else {
1439                enum object_type type;
1440                struct sha1_size_cache *e;
1441
1442                if (size_only) {
1443                        e = locate_size_cache(s->sha1, 1, 0);
1444                        if (e) {
1445                                s->size = e->size;
1446                                return 0;
1447                        }
1448                        type = sha1_object_info(s->sha1, &s->size);
1449                        if (type < 0)
1450                                locate_size_cache(s->sha1, 0, s->size);
1451                }
1452                else {
1453                        s->data = read_sha1_file(s->sha1, &type, &s->size);
1454                        s->should_free = 1;
1455                }
1456        }
1457        return 0;
1458}
1459
1460void diff_free_filespec_data(struct diff_filespec *s)
1461{
1462        if (s->should_free)
1463                free(s->data);
1464        else if (s->should_munmap)
1465                munmap(s->data, s->size);
1466        s->should_free = s->should_munmap = 0;
1467        s->data = NULL;
1468        free(s->cnt_data);
1469        s->cnt_data = NULL;
1470}
1471
1472static void prep_temp_blob(struct diff_tempfile *temp,
1473                           void *blob,
1474                           unsigned long size,
1475                           const unsigned char *sha1,
1476                           int mode)
1477{
1478        int fd;
1479
1480        fd = git_mkstemp(temp->tmp_path, TEMPFILE_PATH_LEN, ".diff_XXXXXX");
1481        if (fd < 0)
1482                die("unable to create temp-file");
1483        if (write_in_full(fd, blob, size) != size)
1484                die("unable to write temp-file");
1485        close(fd);
1486        temp->name = temp->tmp_path;
1487        strcpy(temp->hex, sha1_to_hex(sha1));
1488        temp->hex[40] = 0;
1489        sprintf(temp->mode, "%06o", mode);
1490}
1491
1492static void prepare_temp_file(const char *name,
1493                              struct diff_tempfile *temp,
1494                              struct diff_filespec *one)
1495{
1496        if (!DIFF_FILE_VALID(one)) {
1497        not_a_valid_file:
1498                /* A '-' entry produces this for file-2, and
1499                 * a '+' entry produces this for file-1.
1500                 */
1501                temp->name = "/dev/null";
1502                strcpy(temp->hex, ".");
1503                strcpy(temp->mode, ".");
1504                return;
1505        }
1506
1507        if (!one->sha1_valid ||
1508            reuse_worktree_file(name, one->sha1, 1)) {
1509                struct stat st;
1510                if (lstat(name, &st) < 0) {
1511                        if (errno == ENOENT)
1512                                goto not_a_valid_file;
1513                        die("stat(%s): %s", name, strerror(errno));
1514                }
1515                if (S_ISLNK(st.st_mode)) {
1516                        int ret;
1517                        char buf[PATH_MAX + 1]; /* ought to be SYMLINK_MAX */
1518                        size_t sz = xsize_t(st.st_size);
1519                        if (sizeof(buf) <= st.st_size)
1520                                die("symlink too long: %s", name);
1521                        ret = readlink(name, buf, sz);
1522                        if (ret < 0)
1523                                die("readlink(%s)", name);
1524                        prep_temp_blob(temp, buf, sz,
1525                                       (one->sha1_valid ?
1526                                        one->sha1 : null_sha1),
1527                                       (one->sha1_valid ?
1528                                        one->mode : S_IFLNK));
1529                }
1530                else {
1531                        /* we can borrow from the file in the work tree */
1532                        temp->name = name;
1533                        if (!one->sha1_valid)
1534                                strcpy(temp->hex, sha1_to_hex(null_sha1));
1535                        else
1536                                strcpy(temp->hex, sha1_to_hex(one->sha1));
1537                        /* Even though we may sometimes borrow the
1538                         * contents from the work tree, we always want
1539                         * one->mode.  mode is trustworthy even when
1540                         * !(one->sha1_valid), as long as
1541                         * DIFF_FILE_VALID(one).
1542                         */
1543                        sprintf(temp->mode, "%06o", one->mode);
1544                }
1545                return;
1546        }
1547        else {
1548                if (diff_populate_filespec(one, 0))
1549                        die("cannot read data blob for %s", one->path);
1550                prep_temp_blob(temp, one->data, one->size,
1551                               one->sha1, one->mode);
1552        }
1553}
1554
1555static void remove_tempfile(void)
1556{
1557        int i;
1558
1559        for (i = 0; i < 2; i++)
1560                if (diff_temp[i].name == diff_temp[i].tmp_path) {
1561                        unlink(diff_temp[i].name);
1562                        diff_temp[i].name = NULL;
1563                }
1564}
1565
1566static void remove_tempfile_on_signal(int signo)
1567{
1568        remove_tempfile();
1569        signal(SIGINT, SIG_DFL);
1570        raise(signo);
1571}
1572
1573static int spawn_prog(const char *pgm, const char **arg)
1574{
1575        pid_t pid;
1576        int status;
1577
1578        fflush(NULL);
1579        pid = fork();
1580        if (pid < 0)
1581                die("unable to fork");
1582        if (!pid) {
1583                execvp(pgm, (char *const*) arg);
1584                exit(255);
1585        }
1586
1587        while (waitpid(pid, &status, 0) < 0) {
1588                if (errno == EINTR)
1589                        continue;
1590                return -1;
1591        }
1592
1593        /* Earlier we did not check the exit status because
1594         * diff exits non-zero if files are different, and
1595         * we are not interested in knowing that.  It was a
1596         * mistake which made it harder to quit a diff-*
1597         * session that uses the git-apply-patch-script as
1598         * the GIT_EXTERNAL_DIFF.  A custom GIT_EXTERNAL_DIFF
1599         * should also exit non-zero only when it wants to
1600         * abort the entire diff-* session.
1601         */
1602        if (WIFEXITED(status) && !WEXITSTATUS(status))
1603                return 0;
1604        return -1;
1605}
1606
1607/* An external diff command takes:
1608 *
1609 * diff-cmd name infile1 infile1-sha1 infile1-mode \
1610 *               infile2 infile2-sha1 infile2-mode [ rename-to ]
1611 *
1612 */
1613static void run_external_diff(const char *pgm,
1614                              const char *name,
1615                              const char *other,
1616                              struct diff_filespec *one,
1617                              struct diff_filespec *two,
1618                              const char *xfrm_msg,
1619                              int complete_rewrite)
1620{
1621        const char *spawn_arg[10];
1622        struct diff_tempfile *temp = diff_temp;
1623        int retval;
1624        static int atexit_asked = 0;
1625        const char *othername;
1626        const char **arg = &spawn_arg[0];
1627
1628        othername = (other? other : name);
1629        if (one && two) {
1630                prepare_temp_file(name, &temp[0], one);
1631                prepare_temp_file(othername, &temp[1], two);
1632                if (! atexit_asked &&
1633                    (temp[0].name == temp[0].tmp_path ||
1634                     temp[1].name == temp[1].tmp_path)) {
1635                        atexit_asked = 1;
1636                        atexit(remove_tempfile);
1637                }
1638                signal(SIGINT, remove_tempfile_on_signal);
1639        }
1640
1641        if (one && two) {
1642                *arg++ = pgm;
1643                *arg++ = name;
1644                *arg++ = temp[0].name;
1645                *arg++ = temp[0].hex;
1646                *arg++ = temp[0].mode;
1647                *arg++ = temp[1].name;
1648                *arg++ = temp[1].hex;
1649                *arg++ = temp[1].mode;
1650                if (other) {
1651                        *arg++ = other;
1652                        *arg++ = xfrm_msg;
1653                }
1654        } else {
1655                *arg++ = pgm;
1656                *arg++ = name;
1657        }
1658        *arg = NULL;
1659        retval = spawn_prog(pgm, spawn_arg);
1660        remove_tempfile();
1661        if (retval) {
1662                fprintf(stderr, "external diff died, stopping at %s.\n", name);
1663                exit(1);
1664        }
1665}
1666
1667static void run_diff_cmd(const char *pgm,
1668                         const char *name,
1669                         const char *other,
1670                         struct diff_filespec *one,
1671                         struct diff_filespec *two,
1672                         const char *xfrm_msg,
1673                         struct diff_options *o,
1674                         int complete_rewrite)
1675{
1676        if (pgm) {
1677                run_external_diff(pgm, name, other, one, two, xfrm_msg,
1678                                  complete_rewrite);
1679                return;
1680        }
1681        if (one && two)
1682                builtin_diff(name, other ? other : name,
1683                             one, two, xfrm_msg, o, complete_rewrite);
1684        else
1685                printf("* Unmerged path %s\n", name);
1686}
1687
1688static void diff_fill_sha1_info(struct diff_filespec *one)
1689{
1690        if (DIFF_FILE_VALID(one)) {
1691                if (!one->sha1_valid) {
1692                        struct stat st;
1693                        if (lstat(one->path, &st) < 0)
1694                                die("stat %s", one->path);
1695                        if (index_path(one->sha1, one->path, &st, 0))
1696                                die("cannot hash %s\n", one->path);
1697                }
1698        }
1699        else
1700                hashclr(one->sha1);
1701}
1702
1703static void run_diff(struct diff_filepair *p, struct diff_options *o)
1704{
1705        const char *pgm = external_diff();
1706        char msg[PATH_MAX*2+300], *xfrm_msg;
1707        struct diff_filespec *one;
1708        struct diff_filespec *two;
1709        const char *name;
1710        const char *other;
1711        char *name_munged, *other_munged;
1712        int complete_rewrite = 0;
1713        int len;
1714
1715        if (DIFF_PAIR_UNMERGED(p)) {
1716                /* unmerged */
1717                run_diff_cmd(pgm, p->one->path, NULL, NULL, NULL, NULL, o, 0);
1718                return;
1719        }
1720
1721        name = p->one->path;
1722        other = (strcmp(name, p->two->path) ? p->two->path : NULL);
1723        name_munged = quote_one(name);
1724        other_munged = quote_one(other);
1725        one = p->one; two = p->two;
1726
1727        diff_fill_sha1_info(one);
1728        diff_fill_sha1_info(two);
1729
1730        len = 0;
1731        switch (p->status) {
1732        case DIFF_STATUS_COPIED:
1733                len += snprintf(msg + len, sizeof(msg) - len,
1734                                "similarity index %d%%\n"
1735                                "copy from %s\n"
1736                                "copy to %s\n",
1737                                (int)(0.5 + p->score * 100.0/MAX_SCORE),
1738                                name_munged, other_munged);
1739                break;
1740        case DIFF_STATUS_RENAMED:
1741                len += snprintf(msg + len, sizeof(msg) - len,
1742                                "similarity index %d%%\n"
1743                                "rename from %s\n"
1744                                "rename to %s\n",
1745                                (int)(0.5 + p->score * 100.0/MAX_SCORE),
1746                                name_munged, other_munged);
1747                break;
1748        case DIFF_STATUS_MODIFIED:
1749                if (p->score) {
1750                        len += snprintf(msg + len, sizeof(msg) - len,
1751                                        "dissimilarity index %d%%\n",
1752                                        (int)(0.5 + p->score *
1753                                              100.0/MAX_SCORE));
1754                        complete_rewrite = 1;
1755                        break;
1756                }
1757                /* fallthru */
1758        default:
1759                /* nothing */
1760                ;
1761        }
1762
1763        if (hashcmp(one->sha1, two->sha1)) {
1764                int abbrev = o->full_index ? 40 : DEFAULT_ABBREV;
1765
1766                if (o->binary) {
1767                        mmfile_t mf;
1768                        if ((!fill_mmfile(&mf, one) && mmfile_is_binary(&mf)) ||
1769                            (!fill_mmfile(&mf, two) && mmfile_is_binary(&mf)))
1770                                abbrev = 40;
1771                }
1772                len += snprintf(msg + len, sizeof(msg) - len,
1773                                "index %.*s..%.*s",
1774                                abbrev, sha1_to_hex(one->sha1),
1775                                abbrev, sha1_to_hex(two->sha1));
1776                if (one->mode == two->mode)
1777                        len += snprintf(msg + len, sizeof(msg) - len,
1778                                        " %06o", one->mode);
1779                len += snprintf(msg + len, sizeof(msg) - len, "\n");
1780        }
1781
1782        if (len)
1783                msg[--len] = 0;
1784        xfrm_msg = len ? msg : NULL;
1785
1786        if (!pgm &&
1787            DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) &&
1788            (S_IFMT & one->mode) != (S_IFMT & two->mode)) {
1789                /* a filepair that changes between file and symlink
1790                 * needs to be split into deletion and creation.
1791                 */
1792                struct diff_filespec *null = alloc_filespec(two->path);
1793                run_diff_cmd(NULL, name, other, one, null, xfrm_msg, o, 0);
1794                free(null);
1795                null = alloc_filespec(one->path);
1796                run_diff_cmd(NULL, name, other, null, two, xfrm_msg, o, 0);
1797                free(null);
1798        }
1799        else
1800                run_diff_cmd(pgm, name, other, one, two, xfrm_msg, o,
1801                             complete_rewrite);
1802
1803        free(name_munged);
1804        free(other_munged);
1805}
1806
1807static void run_diffstat(struct diff_filepair *p, struct diff_options *o,
1808                         struct diffstat_t *diffstat)
1809{
1810        const char *name;
1811        const char *other;
1812        int complete_rewrite = 0;
1813
1814        if (DIFF_PAIR_UNMERGED(p)) {
1815                /* unmerged */
1816                builtin_diffstat(p->one->path, NULL, NULL, NULL, diffstat, o, 0);
1817                return;
1818        }
1819
1820        name = p->one->path;
1821        other = (strcmp(name, p->two->path) ? p->two->path : NULL);
1822
1823        diff_fill_sha1_info(p->one);
1824        diff_fill_sha1_info(p->two);
1825
1826        if (p->status == DIFF_STATUS_MODIFIED && p->score)
1827                complete_rewrite = 1;
1828        builtin_diffstat(name, other, p->one, p->two, diffstat, o, complete_rewrite);
1829}
1830
1831static void run_checkdiff(struct diff_filepair *p, struct diff_options *o)
1832{
1833        const char *name;
1834        const char *other;
1835
1836        if (DIFF_PAIR_UNMERGED(p)) {
1837                /* unmerged */
1838                return;
1839        }
1840
1841        name = p->one->path;
1842        other = (strcmp(name, p->two->path) ? p->two->path : NULL);
1843
1844        diff_fill_sha1_info(p->one);
1845        diff_fill_sha1_info(p->two);
1846
1847        builtin_checkdiff(name, other, p->one, p->two, o);
1848}
1849
1850void diff_setup(struct diff_options *options)
1851{
1852        memset(options, 0, sizeof(*options));
1853        options->line_termination = '\n';
1854        options->break_opt = -1;
1855        options->rename_limit = -1;
1856        options->context = 3;
1857        options->msg_sep = "";
1858
1859        options->change = diff_change;
1860        options->add_remove = diff_addremove;
1861        options->color_diff = diff_use_color_default;
1862        options->detect_rename = diff_detect_rename_default;
1863}
1864
1865int diff_setup_done(struct diff_options *options)
1866{
1867        int count = 0;
1868
1869        if (options->output_format & DIFF_FORMAT_NAME)
1870                count++;
1871        if (options->output_format & DIFF_FORMAT_NAME_STATUS)
1872                count++;
1873        if (options->output_format & DIFF_FORMAT_CHECKDIFF)
1874                count++;
1875        if (options->output_format & DIFF_FORMAT_NO_OUTPUT)
1876                count++;
1877        if (count > 1)
1878                die("--name-only, --name-status, --check and -s are mutually exclusive");
1879
1880        if (options->find_copies_harder)
1881                options->detect_rename = DIFF_DETECT_COPY;
1882
1883        if (options->output_format & (DIFF_FORMAT_NAME |
1884                                      DIFF_FORMAT_NAME_STATUS |
1885                                      DIFF_FORMAT_CHECKDIFF |
1886                                      DIFF_FORMAT_NO_OUTPUT))
1887                options->output_format &= ~(DIFF_FORMAT_RAW |
1888                                            DIFF_FORMAT_NUMSTAT |
1889                                            DIFF_FORMAT_DIFFSTAT |
1890                                            DIFF_FORMAT_SHORTSTAT |
1891                                            DIFF_FORMAT_SUMMARY |
1892                                            DIFF_FORMAT_PATCH);
1893
1894        /*
1895         * These cases always need recursive; we do not drop caller-supplied
1896         * recursive bits for other formats here.
1897         */
1898        if (options->output_format & (DIFF_FORMAT_PATCH |
1899                                      DIFF_FORMAT_NUMSTAT |
1900                                      DIFF_FORMAT_DIFFSTAT |
1901                                      DIFF_FORMAT_SHORTSTAT |
1902                                      DIFF_FORMAT_SUMMARY |
1903                                      DIFF_FORMAT_CHECKDIFF))
1904                options->recursive = 1;
1905        /*
1906         * Also pickaxe would not work very well if you do not say recursive
1907         */
1908        if (options->pickaxe)
1909                options->recursive = 1;
1910
1911        if (options->detect_rename && options->rename_limit < 0)
1912                options->rename_limit = diff_rename_limit_default;
1913        if (options->setup & DIFF_SETUP_USE_CACHE) {
1914                if (!active_cache)
1915                        /* read-cache does not die even when it fails
1916                         * so it is safe for us to do this here.  Also
1917                         * it does not smudge active_cache or active_nr
1918                         * when it fails, so we do not have to worry about
1919                         * cleaning it up ourselves either.
1920                         */
1921                        read_cache();
1922        }
1923        if (options->setup & DIFF_SETUP_USE_SIZE_CACHE)
1924                use_size_cache = 1;
1925        if (options->abbrev <= 0 || 40 < options->abbrev)
1926                options->abbrev = 40; /* full */
1927
1928        return 0;
1929}
1930
1931static int opt_arg(const char *arg, int arg_short, const char *arg_long, int *val)
1932{
1933        char c, *eq;
1934        int len;
1935
1936        if (*arg != '-')
1937                return 0;
1938        c = *++arg;
1939        if (!c)
1940                return 0;
1941        if (c == arg_short) {
1942                c = *++arg;
1943                if (!c)
1944                        return 1;
1945                if (val && isdigit(c)) {
1946                        char *end;
1947                        int n = strtoul(arg, &end, 10);
1948                        if (*end)
1949                                return 0;
1950                        *val = n;
1951                        return 1;
1952                }
1953                return 0;
1954        }
1955        if (c != '-')
1956                return 0;
1957        arg++;
1958        eq = strchr(arg, '=');
1959        if (eq)
1960                len = eq - arg;
1961        else
1962                len = strlen(arg);
1963        if (!len || strncmp(arg, arg_long, len))
1964                return 0;
1965        if (eq) {
1966                int n;
1967                char *end;
1968                if (!isdigit(*++eq))
1969                        return 0;
1970                n = strtoul(eq, &end, 10);
1971                if (*end)
1972                        return 0;
1973                *val = n;
1974        }
1975        return 1;
1976}
1977
1978int diff_opt_parse(struct diff_options *options, const char **av, int ac)
1979{
1980        const char *arg = av[0];
1981        if (!strcmp(arg, "-p") || !strcmp(arg, "-u"))
1982                options->output_format |= DIFF_FORMAT_PATCH;
1983        else if (opt_arg(arg, 'U', "unified", &options->context))
1984                options->output_format |= DIFF_FORMAT_PATCH;
1985        else if (!strcmp(arg, "--raw"))
1986                options->output_format |= DIFF_FORMAT_RAW;
1987        else if (!strcmp(arg, "--patch-with-raw")) {
1988                options->output_format |= DIFF_FORMAT_PATCH | DIFF_FORMAT_RAW;
1989        }
1990        else if (!strcmp(arg, "--numstat")) {
1991                options->output_format |= DIFF_FORMAT_NUMSTAT;
1992        }
1993        else if (!strcmp(arg, "--shortstat")) {
1994                options->output_format |= DIFF_FORMAT_SHORTSTAT;
1995        }
1996        else if (!prefixcmp(arg, "--stat")) {
1997                char *end;
1998                int width = options->stat_width;
1999                int name_width = options->stat_name_width;
2000                arg += 6;
2001                end = (char *)arg;
2002
2003                switch (*arg) {
2004                case '-':
2005                        if (!prefixcmp(arg, "-width="))
2006                                width = strtoul(arg + 7, &end, 10);
2007                        else if (!prefixcmp(arg, "-name-width="))
2008                                name_width = strtoul(arg + 12, &end, 10);
2009                        break;
2010                case '=':
2011                        width = strtoul(arg+1, &end, 10);
2012                        if (*end == ',')
2013                                name_width = strtoul(end+1, &end, 10);
2014                }
2015
2016                /* Important! This checks all the error cases! */
2017                if (*end)
2018                        return 0;
2019                options->output_format |= DIFF_FORMAT_DIFFSTAT;
2020                options->stat_name_width = name_width;
2021                options->stat_width = width;
2022        }
2023        else if (!strcmp(arg, "--check"))
2024                options->output_format |= DIFF_FORMAT_CHECKDIFF;
2025        else if (!strcmp(arg, "--summary"))
2026                options->output_format |= DIFF_FORMAT_SUMMARY;
2027        else if (!strcmp(arg, "--patch-with-stat")) {
2028                options->output_format |= DIFF_FORMAT_PATCH | DIFF_FORMAT_DIFFSTAT;
2029        }
2030        else if (!strcmp(arg, "-z"))
2031                options->line_termination = 0;
2032        else if (!prefixcmp(arg, "-l"))
2033                options->rename_limit = strtoul(arg+2, NULL, 10);
2034        else if (!strcmp(arg, "--full-index"))
2035                options->full_index = 1;
2036        else if (!strcmp(arg, "--binary")) {
2037                options->output_format |= DIFF_FORMAT_PATCH;
2038                options->binary = 1;
2039        }
2040        else if (!strcmp(arg, "-a") || !strcmp(arg, "--text")) {
2041                options->text = 1;
2042        }
2043        else if (!strcmp(arg, "--name-only"))
2044                options->output_format |= DIFF_FORMAT_NAME;
2045        else if (!strcmp(arg, "--name-status"))
2046                options->output_format |= DIFF_FORMAT_NAME_STATUS;
2047        else if (!strcmp(arg, "-R"))
2048                options->reverse_diff = 1;
2049        else if (!prefixcmp(arg, "-S"))
2050                options->pickaxe = arg + 2;
2051        else if (!strcmp(arg, "-s")) {
2052                options->output_format |= DIFF_FORMAT_NO_OUTPUT;
2053        }
2054        else if (!prefixcmp(arg, "-O"))
2055                options->orderfile = arg + 2;
2056        else if (!prefixcmp(arg, "--diff-filter="))
2057                options->filter = arg + 14;
2058        else if (!strcmp(arg, "--pickaxe-all"))
2059                options->pickaxe_opts = DIFF_PICKAXE_ALL;
2060        else if (!strcmp(arg, "--pickaxe-regex"))
2061                options->pickaxe_opts = DIFF_PICKAXE_REGEX;
2062        else if (!prefixcmp(arg, "-B")) {
2063                if ((options->break_opt =
2064                     diff_scoreopt_parse(arg)) == -1)
2065                        return -1;
2066        }
2067        else if (!prefixcmp(arg, "-M")) {
2068                if ((options->rename_score =
2069                     diff_scoreopt_parse(arg)) == -1)
2070                        return -1;
2071                options->detect_rename = DIFF_DETECT_RENAME;
2072        }
2073        else if (!prefixcmp(arg, "-C")) {
2074                if ((options->rename_score =
2075                     diff_scoreopt_parse(arg)) == -1)
2076                        return -1;
2077                options->detect_rename = DIFF_DETECT_COPY;
2078        }
2079        else if (!strcmp(arg, "--find-copies-harder"))
2080                options->find_copies_harder = 1;
2081        else if (!strcmp(arg, "--abbrev"))
2082                options->abbrev = DEFAULT_ABBREV;
2083        else if (!prefixcmp(arg, "--abbrev=")) {
2084                options->abbrev = strtoul(arg + 9, NULL, 10);
2085                if (options->abbrev < MINIMUM_ABBREV)
2086                        options->abbrev = MINIMUM_ABBREV;
2087                else if (40 < options->abbrev)
2088                        options->abbrev = 40;
2089        }
2090        else if (!strcmp(arg, "--color"))
2091                options->color_diff = 1;
2092        else if (!strcmp(arg, "--no-color"))
2093                options->color_diff = 0;
2094        else if (!strcmp(arg, "-w") || !strcmp(arg, "--ignore-all-space"))
2095                options->xdl_opts |= XDF_IGNORE_WHITESPACE;
2096        else if (!strcmp(arg, "-b") || !strcmp(arg, "--ignore-space-change"))
2097                options->xdl_opts |= XDF_IGNORE_WHITESPACE_CHANGE;
2098        else if (!strcmp(arg, "--ignore-space-at-eol"))
2099                options->xdl_opts |= XDF_IGNORE_WHITESPACE_AT_EOL;
2100        else if (!strcmp(arg, "--color-words"))
2101                options->color_diff = options->color_diff_words = 1;
2102        else if (!strcmp(arg, "--no-renames"))
2103                options->detect_rename = 0;
2104        else
2105                return 0;
2106        return 1;
2107}
2108
2109static int parse_num(const char **cp_p)
2110{
2111        unsigned long num, scale;
2112        int ch, dot;
2113        const char *cp = *cp_p;
2114
2115        num = 0;
2116        scale = 1;
2117        dot = 0;
2118        for(;;) {
2119                ch = *cp;
2120                if ( !dot && ch == '.' ) {
2121                        scale = 1;
2122                        dot = 1;
2123                } else if ( ch == '%' ) {
2124                        scale = dot ? scale*100 : 100;
2125                        cp++;   /* % is always at the end */
2126                        break;
2127                } else if ( ch >= '0' && ch <= '9' ) {
2128                        if ( scale < 100000 ) {
2129                                scale *= 10;
2130                                num = (num*10) + (ch-'0');
2131                        }
2132                } else {
2133                        break;
2134                }
2135                cp++;
2136        }
2137        *cp_p = cp;
2138
2139        /* user says num divided by scale and we say internally that
2140         * is MAX_SCORE * num / scale.
2141         */
2142        return (int)((num >= scale) ? MAX_SCORE : (MAX_SCORE * num / scale));
2143}
2144
2145int diff_scoreopt_parse(const char *opt)
2146{
2147        int opt1, opt2, cmd;
2148
2149        if (*opt++ != '-')
2150                return -1;
2151        cmd = *opt++;
2152        if (cmd != 'M' && cmd != 'C' && cmd != 'B')
2153                return -1; /* that is not a -M, -C nor -B option */
2154
2155        opt1 = parse_num(&opt);
2156        if (cmd != 'B')
2157                opt2 = 0;
2158        else {
2159                if (*opt == 0)
2160                        opt2 = 0;
2161                else if (*opt != '/')
2162                        return -1; /* we expect -B80/99 or -B80 */
2163                else {
2164                        opt++;
2165                        opt2 = parse_num(&opt);
2166                }
2167        }
2168        if (*opt != 0)
2169                return -1;
2170        return opt1 | (opt2 << 16);
2171}
2172
2173struct diff_queue_struct diff_queued_diff;
2174
2175void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp)
2176{
2177        if (queue->alloc <= queue->nr) {
2178                queue->alloc = alloc_nr(queue->alloc);
2179                queue->queue = xrealloc(queue->queue,
2180                                        sizeof(dp) * queue->alloc);
2181        }
2182        queue->queue[queue->nr++] = dp;
2183}
2184
2185struct diff_filepair *diff_queue(struct diff_queue_struct *queue,
2186                                 struct diff_filespec *one,
2187                                 struct diff_filespec *two)
2188{
2189        struct diff_filepair *dp = xcalloc(1, sizeof(*dp));
2190        dp->one = one;
2191        dp->two = two;
2192        if (queue)
2193                diff_q(queue, dp);
2194        return dp;
2195}
2196
2197void diff_free_filepair(struct diff_filepair *p)
2198{
2199        diff_free_filespec_data(p->one);
2200        diff_free_filespec_data(p->two);
2201        free(p->one);
2202        free(p->two);
2203        free(p);
2204}
2205
2206/* This is different from find_unique_abbrev() in that
2207 * it stuffs the result with dots for alignment.
2208 */
2209const char *diff_unique_abbrev(const unsigned char *sha1, int len)
2210{
2211        int abblen;
2212        const char *abbrev;
2213        if (len == 40)
2214                return sha1_to_hex(sha1);
2215
2216        abbrev = find_unique_abbrev(sha1, len);
2217        if (!abbrev)
2218                return sha1_to_hex(sha1);
2219        abblen = strlen(abbrev);
2220        if (abblen < 37) {
2221                static char hex[41];
2222                if (len < abblen && abblen <= len + 2)
2223                        sprintf(hex, "%s%.*s", abbrev, len+3-abblen, "..");
2224                else
2225                        sprintf(hex, "%s...", abbrev);
2226                return hex;
2227        }
2228        return sha1_to_hex(sha1);
2229}
2230
2231static void diff_flush_raw(struct diff_filepair *p,
2232                           struct diff_options *options)
2233{
2234        int two_paths;
2235        char status[10];
2236        int abbrev = options->abbrev;
2237        const char *path_one, *path_two;
2238        int inter_name_termination = '\t';
2239        int line_termination = options->line_termination;
2240
2241        if (!line_termination)
2242                inter_name_termination = 0;
2243
2244        path_one = p->one->path;
2245        path_two = p->two->path;
2246        if (line_termination) {
2247                path_one = quote_one(path_one);
2248                path_two = quote_one(path_two);
2249        }
2250
2251        if (p->score)
2252                sprintf(status, "%c%03d", p->status,
2253                        (int)(0.5 + p->score * 100.0/MAX_SCORE));
2254        else {
2255                status[0] = p->status;
2256                status[1] = 0;
2257        }
2258        switch (p->status) {
2259        case DIFF_STATUS_COPIED:
2260        case DIFF_STATUS_RENAMED:
2261                two_paths = 1;
2262                break;
2263        case DIFF_STATUS_ADDED:
2264        case DIFF_STATUS_DELETED:
2265                two_paths = 0;
2266                break;
2267        default:
2268                two_paths = 0;
2269                break;
2270        }
2271        if (!(options->output_format & DIFF_FORMAT_NAME_STATUS)) {
2272                printf(":%06o %06o %s ",
2273                       p->one->mode, p->two->mode,
2274                       diff_unique_abbrev(p->one->sha1, abbrev));
2275                printf("%s ",
2276                       diff_unique_abbrev(p->two->sha1, abbrev));
2277        }
2278        printf("%s%c%s", status, inter_name_termination, path_one);
2279        if (two_paths)
2280                printf("%c%s", inter_name_termination, path_two);
2281        putchar(line_termination);
2282        if (path_one != p->one->path)
2283                free((void*)path_one);
2284        if (path_two != p->two->path)
2285                free((void*)path_two);
2286}
2287
2288static void diff_flush_name(struct diff_filepair *p, struct diff_options *opt)
2289{
2290        char *path = p->two->path;
2291
2292        if (opt->line_termination)
2293                path = quote_one(p->two->path);
2294        printf("%s%c", path, opt->line_termination);
2295        if (p->two->path != path)
2296                free(path);
2297}
2298
2299int diff_unmodified_pair(struct diff_filepair *p)
2300{
2301        /* This function is written stricter than necessary to support
2302         * the currently implemented transformers, but the idea is to
2303         * let transformers to produce diff_filepairs any way they want,
2304         * and filter and clean them up here before producing the output.
2305         */
2306        struct diff_filespec *one, *two;
2307
2308        if (DIFF_PAIR_UNMERGED(p))
2309                return 0; /* unmerged is interesting */
2310
2311        one = p->one;
2312        two = p->two;
2313
2314        /* deletion, addition, mode or type change
2315         * and rename are all interesting.
2316         */
2317        if (DIFF_FILE_VALID(one) != DIFF_FILE_VALID(two) ||
2318            DIFF_PAIR_MODE_CHANGED(p) ||
2319            strcmp(one->path, two->path))
2320                return 0;
2321
2322        /* both are valid and point at the same path.  that is, we are
2323         * dealing with a change.
2324         */
2325        if (one->sha1_valid && two->sha1_valid &&
2326            !hashcmp(one->sha1, two->sha1))
2327                return 1; /* no change */
2328        if (!one->sha1_valid && !two->sha1_valid)
2329                return 1; /* both look at the same file on the filesystem. */
2330        return 0;
2331}
2332
2333static void diff_flush_patch(struct diff_filepair *p, struct diff_options *o)
2334{
2335        if (diff_unmodified_pair(p))
2336                return;
2337
2338        if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
2339            (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
2340                return; /* no tree diffs in patch format */
2341
2342        run_diff(p, o);
2343}
2344
2345static void diff_flush_stat(struct diff_filepair *p, struct diff_options *o,
2346                            struct diffstat_t *diffstat)
2347{
2348        if (diff_unmodified_pair(p))
2349                return;
2350
2351        if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
2352            (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
2353                return; /* no tree diffs in patch format */
2354
2355        run_diffstat(p, o, diffstat);
2356}
2357
2358static void diff_flush_checkdiff(struct diff_filepair *p,
2359                struct diff_options *o)
2360{
2361        if (diff_unmodified_pair(p))
2362                return;
2363
2364        if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
2365            (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
2366                return; /* no tree diffs in patch format */
2367
2368        run_checkdiff(p, o);
2369}
2370
2371int diff_queue_is_empty(void)
2372{
2373        struct diff_queue_struct *q = &diff_queued_diff;
2374        int i;
2375        for (i = 0; i < q->nr; i++)
2376                if (!diff_unmodified_pair(q->queue[i]))
2377                        return 0;
2378        return 1;
2379}
2380
2381#if DIFF_DEBUG
2382void diff_debug_filespec(struct diff_filespec *s, int x, const char *one)
2383{
2384        fprintf(stderr, "queue[%d] %s (%s) %s %06o %s\n",
2385                x, one ? one : "",
2386                s->path,
2387                DIFF_FILE_VALID(s) ? "valid" : "invalid",
2388                s->mode,
2389                s->sha1_valid ? sha1_to_hex(s->sha1) : "");
2390        fprintf(stderr, "queue[%d] %s size %lu flags %d\n",
2391                x, one ? one : "",
2392                s->size, s->xfrm_flags);
2393}
2394
2395void diff_debug_filepair(const struct diff_filepair *p, int i)
2396{
2397        diff_debug_filespec(p->one, i, "one");
2398        diff_debug_filespec(p->two, i, "two");
2399        fprintf(stderr, "score %d, status %c stays %d broken %d\n",
2400                p->score, p->status ? p->status : '?',
2401                p->source_stays, p->broken_pair);
2402}
2403
2404void diff_debug_queue(const char *msg, struct diff_queue_struct *q)
2405{
2406        int i;
2407        if (msg)
2408                fprintf(stderr, "%s\n", msg);
2409        fprintf(stderr, "q->nr = %d\n", q->nr);
2410        for (i = 0; i < q->nr; i++) {
2411                struct diff_filepair *p = q->queue[i];
2412                diff_debug_filepair(p, i);
2413        }
2414}
2415#endif
2416
2417static void diff_resolve_rename_copy(void)
2418{
2419        int i, j;
2420        struct diff_filepair *p, *pp;
2421        struct diff_queue_struct *q = &diff_queued_diff;
2422
2423        diff_debug_queue("resolve-rename-copy", q);
2424
2425        for (i = 0; i < q->nr; i++) {
2426                p = q->queue[i];
2427                p->status = 0; /* undecided */
2428                if (DIFF_PAIR_UNMERGED(p))
2429                        p->status = DIFF_STATUS_UNMERGED;
2430                else if (!DIFF_FILE_VALID(p->one))
2431                        p->status = DIFF_STATUS_ADDED;
2432                else if (!DIFF_FILE_VALID(p->two))
2433                        p->status = DIFF_STATUS_DELETED;
2434                else if (DIFF_PAIR_TYPE_CHANGED(p))
2435                        p->status = DIFF_STATUS_TYPE_CHANGED;
2436
2437                /* from this point on, we are dealing with a pair
2438                 * whose both sides are valid and of the same type, i.e.
2439                 * either in-place edit or rename/copy edit.
2440                 */
2441                else if (DIFF_PAIR_RENAME(p)) {
2442                        if (p->source_stays) {
2443                                p->status = DIFF_STATUS_COPIED;
2444                                continue;
2445                        }
2446                        /* See if there is some other filepair that
2447                         * copies from the same source as us.  If so
2448                         * we are a copy.  Otherwise we are either a
2449                         * copy if the path stays, or a rename if it
2450                         * does not, but we already handled "stays" case.
2451                         */
2452                        for (j = i + 1; j < q->nr; j++) {
2453                                pp = q->queue[j];
2454                                if (strcmp(pp->one->path, p->one->path))
2455                                        continue; /* not us */
2456                                if (!DIFF_PAIR_RENAME(pp))
2457                                        continue; /* not a rename/copy */
2458                                /* pp is a rename/copy from the same source */
2459                                p->status = DIFF_STATUS_COPIED;
2460                                break;
2461                        }
2462                        if (!p->status)
2463                                p->status = DIFF_STATUS_RENAMED;
2464                }
2465                else if (hashcmp(p->one->sha1, p->two->sha1) ||
2466                         p->one->mode != p->two->mode ||
2467                         is_null_sha1(p->one->sha1))
2468                        p->status = DIFF_STATUS_MODIFIED;
2469                else {
2470                        /* This is a "no-change" entry and should not
2471                         * happen anymore, but prepare for broken callers.
2472                         */
2473                        error("feeding unmodified %s to diffcore",
2474                              p->one->path);
2475                        p->status = DIFF_STATUS_UNKNOWN;
2476                }
2477        }
2478        diff_debug_queue("resolve-rename-copy done", q);
2479}
2480
2481static int check_pair_status(struct diff_filepair *p)
2482{
2483        switch (p->status) {
2484        case DIFF_STATUS_UNKNOWN:
2485                return 0;
2486        case 0:
2487                die("internal error in diff-resolve-rename-copy");
2488        default:
2489                return 1;
2490        }
2491}
2492
2493static void flush_one_pair(struct diff_filepair *p, struct diff_options *opt)
2494{
2495        int fmt = opt->output_format;
2496
2497        if (fmt & DIFF_FORMAT_CHECKDIFF)
2498                diff_flush_checkdiff(p, opt);
2499        else if (fmt & (DIFF_FORMAT_RAW | DIFF_FORMAT_NAME_STATUS))
2500                diff_flush_raw(p, opt);
2501        else if (fmt & DIFF_FORMAT_NAME)
2502                diff_flush_name(p, opt);
2503}
2504
2505static void show_file_mode_name(const char *newdelete, struct diff_filespec *fs)
2506{
2507        char *name = quote_one(fs->path);
2508        if (fs->mode)
2509                printf(" %s mode %06o %s\n", newdelete, fs->mode, name);
2510        else
2511                printf(" %s %s\n", newdelete, name);
2512        free(name);
2513}
2514
2515
2516static void show_mode_change(struct diff_filepair *p, int show_name)
2517{
2518        if (p->one->mode && p->two->mode && p->one->mode != p->two->mode) {
2519                if (show_name) {
2520                        char *name = quote_one(p->two->path);
2521                        printf(" mode change %06o => %06o %s\n",
2522                               p->one->mode, p->two->mode, name);
2523                        free(name);
2524                }
2525                else
2526                        printf(" mode change %06o => %06o\n",
2527                               p->one->mode, p->two->mode);
2528        }
2529}
2530
2531static void show_rename_copy(const char *renamecopy, struct diff_filepair *p)
2532{
2533        char *names = pprint_rename(p->one->path, p->two->path);
2534
2535        printf(" %s %s (%d%%)\n", renamecopy, names,
2536               (int)(0.5 + p->score * 100.0/MAX_SCORE));
2537        free(names);
2538        show_mode_change(p, 0);
2539}
2540
2541static void diff_summary(struct diff_filepair *p)
2542{
2543        switch(p->status) {
2544        case DIFF_STATUS_DELETED:
2545                show_file_mode_name("delete", p->one);
2546                break;
2547        case DIFF_STATUS_ADDED:
2548                show_file_mode_name("create", p->two);
2549                break;
2550        case DIFF_STATUS_COPIED:
2551                show_rename_copy("copy", p);
2552                break;
2553        case DIFF_STATUS_RENAMED:
2554                show_rename_copy("rename", p);
2555                break;
2556        default:
2557                if (p->score) {
2558                        char *name = quote_one(p->two->path);
2559                        printf(" rewrite %s (%d%%)\n", name,
2560                                (int)(0.5 + p->score * 100.0/MAX_SCORE));
2561                        free(name);
2562                        show_mode_change(p, 0);
2563                } else  show_mode_change(p, 1);
2564                break;
2565        }
2566}
2567
2568struct patch_id_t {
2569        struct xdiff_emit_state xm;
2570        SHA_CTX *ctx;
2571        int patchlen;
2572};
2573
2574static int remove_space(char *line, int len)
2575{
2576        int i;
2577        char *dst = line;
2578        unsigned char c;
2579
2580        for (i = 0; i < len; i++)
2581                if (!isspace((c = line[i])))
2582                        *dst++ = c;
2583
2584        return dst - line;
2585}
2586
2587static void patch_id_consume(void *priv, char *line, unsigned long len)
2588{
2589        struct patch_id_t *data = priv;
2590        int new_len;
2591
2592        /* Ignore line numbers when computing the SHA1 of the patch */
2593        if (!prefixcmp(line, "@@ -"))
2594                return;
2595
2596        new_len = remove_space(line, len);
2597
2598        SHA1_Update(data->ctx, line, new_len);
2599        data->patchlen += new_len;
2600}
2601
2602/* returns 0 upon success, and writes result into sha1 */
2603static int diff_get_patch_id(struct diff_options *options, unsigned char *sha1)
2604{
2605        struct diff_queue_struct *q = &diff_queued_diff;
2606        int i;
2607        SHA_CTX ctx;
2608        struct patch_id_t data;
2609        char buffer[PATH_MAX * 4 + 20];
2610
2611        SHA1_Init(&ctx);
2612        memset(&data, 0, sizeof(struct patch_id_t));
2613        data.ctx = &ctx;
2614        data.xm.consume = patch_id_consume;
2615
2616        for (i = 0; i < q->nr; i++) {
2617                xpparam_t xpp;
2618                xdemitconf_t xecfg;
2619                xdemitcb_t ecb;
2620                mmfile_t mf1, mf2;
2621                struct diff_filepair *p = q->queue[i];
2622                int len1, len2;
2623
2624                if (p->status == 0)
2625                        return error("internal diff status error");
2626                if (p->status == DIFF_STATUS_UNKNOWN)
2627                        continue;
2628                if (diff_unmodified_pair(p))
2629                        continue;
2630                if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
2631                    (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
2632                        continue;
2633                if (DIFF_PAIR_UNMERGED(p))
2634                        continue;
2635
2636                diff_fill_sha1_info(p->one);
2637                diff_fill_sha1_info(p->two);
2638                if (fill_mmfile(&mf1, p->one) < 0 ||
2639                                fill_mmfile(&mf2, p->two) < 0)
2640                        return error("unable to read files to diff");
2641
2642                /* Maybe hash p->two? into the patch id? */
2643                if (mmfile_is_binary(&mf2))
2644                        continue;
2645
2646                len1 = remove_space(p->one->path, strlen(p->one->path));
2647                len2 = remove_space(p->two->path, strlen(p->two->path));
2648                if (p->one->mode == 0)
2649                        len1 = snprintf(buffer, sizeof(buffer),
2650                                        "diff--gita/%.*sb/%.*s"
2651                                        "newfilemode%06o"
2652                                        "---/dev/null"
2653                                        "+++b/%.*s",
2654                                        len1, p->one->path,
2655                                        len2, p->two->path,
2656                                        p->two->mode,
2657                                        len2, p->two->path);
2658                else if (p->two->mode == 0)
2659                        len1 = snprintf(buffer, sizeof(buffer),
2660                                        "diff--gita/%.*sb/%.*s"
2661                                        "deletedfilemode%06o"
2662                                        "---a/%.*s"
2663                                        "+++/dev/null",
2664                                        len1, p->one->path,
2665                                        len2, p->two->path,
2666                                        p->one->mode,
2667                                        len1, p->one->path);
2668                else
2669                        len1 = snprintf(buffer, sizeof(buffer),
2670                                        "diff--gita/%.*sb/%.*s"
2671                                        "---a/%.*s"
2672                                        "+++b/%.*s",
2673                                        len1, p->one->path,
2674                                        len2, p->two->path,
2675                                        len1, p->one->path,
2676                                        len2, p->two->path);
2677                SHA1_Update(&ctx, buffer, len1);
2678
2679                xpp.flags = XDF_NEED_MINIMAL;
2680                xecfg.ctxlen = 3;
2681                xecfg.flags = XDL_EMIT_FUNCNAMES;
2682                ecb.outf = xdiff_outf;
2683                ecb.priv = &data;
2684                xdl_diff(&mf1, &mf2, &xpp, &xecfg, &ecb);
2685        }
2686
2687        SHA1_Final(sha1, &ctx);
2688        return 0;
2689}
2690
2691int diff_flush_patch_id(struct diff_options *options, unsigned char *sha1)
2692{
2693        struct diff_queue_struct *q = &diff_queued_diff;
2694        int i;
2695        int result = diff_get_patch_id(options, sha1);
2696
2697        for (i = 0; i < q->nr; i++)
2698                diff_free_filepair(q->queue[i]);
2699
2700        free(q->queue);
2701        q->queue = NULL;
2702        q->nr = q->alloc = 0;
2703
2704        return result;
2705}
2706
2707static int is_summary_empty(const struct diff_queue_struct *q)
2708{
2709        int i;
2710
2711        for (i = 0; i < q->nr; i++) {
2712                const struct diff_filepair *p = q->queue[i];
2713
2714                switch (p->status) {
2715                case DIFF_STATUS_DELETED:
2716                case DIFF_STATUS_ADDED:
2717                case DIFF_STATUS_COPIED:
2718                case DIFF_STATUS_RENAMED:
2719                        return 0;
2720                default:
2721                        if (p->score)
2722                                return 0;
2723                        if (p->one->mode && p->two->mode &&
2724                            p->one->mode != p->two->mode)
2725                                return 0;
2726                        break;
2727                }
2728        }
2729        return 1;
2730}
2731
2732void diff_flush(struct diff_options *options)
2733{
2734        struct diff_queue_struct *q = &diff_queued_diff;
2735        int i, output_format = options->output_format;
2736        int separator = 0;
2737
2738        /*
2739         * Order: raw, stat, summary, patch
2740         * or:    name/name-status/checkdiff (other bits clear)
2741         */
2742        if (!q->nr)
2743                goto free_queue;
2744
2745        if (output_format & (DIFF_FORMAT_RAW |
2746                             DIFF_FORMAT_NAME |
2747                             DIFF_FORMAT_NAME_STATUS |
2748                             DIFF_FORMAT_CHECKDIFF)) {
2749                for (i = 0; i < q->nr; i++) {
2750                        struct diff_filepair *p = q->queue[i];
2751                        if (check_pair_status(p))
2752                                flush_one_pair(p, options);
2753                }
2754                separator++;
2755        }
2756
2757        if (output_format & (DIFF_FORMAT_DIFFSTAT|DIFF_FORMAT_SHORTSTAT|DIFF_FORMAT_NUMSTAT)) {
2758                struct diffstat_t diffstat;
2759
2760                memset(&diffstat, 0, sizeof(struct diffstat_t));
2761                diffstat.xm.consume = diffstat_consume;
2762                for (i = 0; i < q->nr; i++) {
2763                        struct diff_filepair *p = q->queue[i];
2764                        if (check_pair_status(p))
2765                                diff_flush_stat(p, options, &diffstat);
2766                }
2767                if (output_format & DIFF_FORMAT_NUMSTAT)
2768                        show_numstat(&diffstat, options);
2769                if (output_format & DIFF_FORMAT_DIFFSTAT)
2770                        show_stats(&diffstat, options);
2771                else if (output_format & DIFF_FORMAT_SHORTSTAT)
2772                        show_shortstats(&diffstat);
2773                separator++;
2774        }
2775
2776        if (output_format & DIFF_FORMAT_SUMMARY && !is_summary_empty(q)) {
2777                for (i = 0; i < q->nr; i++)
2778                        diff_summary(q->queue[i]);
2779                separator++;
2780        }
2781
2782        if (output_format & DIFF_FORMAT_PATCH) {
2783                if (separator) {
2784                        if (options->stat_sep) {
2785                                /* attach patch instead of inline */
2786                                fputs(options->stat_sep, stdout);
2787                        } else {
2788                                putchar(options->line_termination);
2789                        }
2790                }
2791
2792                for (i = 0; i < q->nr; i++) {
2793                        struct diff_filepair *p = q->queue[i];
2794                        if (check_pair_status(p))
2795                                diff_flush_patch(p, options);
2796                }
2797        }
2798
2799        if (output_format & DIFF_FORMAT_CALLBACK)
2800                options->format_callback(q, options, options->format_callback_data);
2801
2802        for (i = 0; i < q->nr; i++)
2803                diff_free_filepair(q->queue[i]);
2804free_queue:
2805        free(q->queue);
2806        q->queue = NULL;
2807        q->nr = q->alloc = 0;
2808}
2809
2810static void diffcore_apply_filter(const char *filter)
2811{
2812        int i;
2813        struct diff_queue_struct *q = &diff_queued_diff;
2814        struct diff_queue_struct outq;
2815        outq.queue = NULL;
2816        outq.nr = outq.alloc = 0;
2817
2818        if (!filter)
2819                return;
2820
2821        if (strchr(filter, DIFF_STATUS_FILTER_AON)) {
2822                int found;
2823                for (i = found = 0; !found && i < q->nr; i++) {
2824                        struct diff_filepair *p = q->queue[i];
2825                        if (((p->status == DIFF_STATUS_MODIFIED) &&
2826                             ((p->score &&
2827                               strchr(filter, DIFF_STATUS_FILTER_BROKEN)) ||
2828                              (!p->score &&
2829                               strchr(filter, DIFF_STATUS_MODIFIED)))) ||
2830                            ((p->status != DIFF_STATUS_MODIFIED) &&
2831                             strchr(filter, p->status)))
2832                                found++;
2833                }
2834                if (found)
2835                        return;
2836
2837                /* otherwise we will clear the whole queue
2838                 * by copying the empty outq at the end of this
2839                 * function, but first clear the current entries
2840                 * in the queue.
2841                 */
2842                for (i = 0; i < q->nr; i++)
2843                        diff_free_filepair(q->queue[i]);
2844        }
2845        else {
2846                /* Only the matching ones */
2847                for (i = 0; i < q->nr; i++) {
2848                        struct diff_filepair *p = q->queue[i];
2849
2850                        if (((p->status == DIFF_STATUS_MODIFIED) &&
2851                             ((p->score &&
2852                               strchr(filter, DIFF_STATUS_FILTER_BROKEN)) ||
2853                              (!p->score &&
2854                               strchr(filter, DIFF_STATUS_MODIFIED)))) ||
2855                            ((p->status != DIFF_STATUS_MODIFIED) &&
2856                             strchr(filter, p->status)))
2857                                diff_q(&outq, p);
2858                        else
2859                                diff_free_filepair(p);
2860                }
2861        }
2862        free(q->queue);
2863        *q = outq;
2864}
2865
2866void diffcore_std(struct diff_options *options)
2867{
2868        if (options->break_opt != -1)
2869                diffcore_break(options->break_opt);
2870        if (options->detect_rename)
2871                diffcore_rename(options);
2872        if (options->break_opt != -1)
2873                diffcore_merge_broken();
2874        if (options->pickaxe)
2875                diffcore_pickaxe(options->pickaxe, options->pickaxe_opts);
2876        if (options->orderfile)
2877                diffcore_order(options->orderfile);
2878        diff_resolve_rename_copy();
2879        diffcore_apply_filter(options->filter);
2880}
2881
2882
2883void diffcore_std_no_resolve(struct diff_options *options)
2884{
2885        if (options->pickaxe)
2886                diffcore_pickaxe(options->pickaxe, options->pickaxe_opts);
2887        if (options->orderfile)
2888                diffcore_order(options->orderfile);
2889        diffcore_apply_filter(options->filter);
2890}
2891
2892void diff_addremove(struct diff_options *options,
2893                    int addremove, unsigned mode,
2894                    const unsigned char *sha1,
2895                    const char *base, const char *path)
2896{
2897        char concatpath[PATH_MAX];
2898        struct diff_filespec *one, *two;
2899
2900        /* This may look odd, but it is a preparation for
2901         * feeding "there are unchanged files which should
2902         * not produce diffs, but when you are doing copy
2903         * detection you would need them, so here they are"
2904         * entries to the diff-core.  They will be prefixed
2905         * with something like '=' or '*' (I haven't decided
2906         * which but should not make any difference).
2907         * Feeding the same new and old to diff_change() 
2908         * also has the same effect.
2909         * Before the final output happens, they are pruned after
2910         * merged into rename/copy pairs as appropriate.
2911         */
2912        if (options->reverse_diff)
2913                addremove = (addremove == '+' ? '-' :
2914                             addremove == '-' ? '+' : addremove);
2915
2916        if (!path) path = "";
2917        sprintf(concatpath, "%s%s", base, path);
2918        one = alloc_filespec(concatpath);
2919        two = alloc_filespec(concatpath);
2920
2921        if (addremove != '+')
2922                fill_filespec(one, sha1, mode);
2923        if (addremove != '-')
2924                fill_filespec(two, sha1, mode);
2925
2926        diff_queue(&diff_queued_diff, one, two);
2927}
2928
2929void diff_change(struct diff_options *options,
2930                 unsigned old_mode, unsigned new_mode,
2931                 const unsigned char *old_sha1,
2932                 const unsigned char *new_sha1,
2933                 const char *base, const char *path) 
2934{
2935        char concatpath[PATH_MAX];
2936        struct diff_filespec *one, *two;
2937
2938        if (options->reverse_diff) {
2939                unsigned tmp;
2940                const unsigned char *tmp_c;
2941                tmp = old_mode; old_mode = new_mode; new_mode = tmp;
2942                tmp_c = old_sha1; old_sha1 = new_sha1; new_sha1 = tmp_c;
2943        }
2944        if (!path) path = "";
2945        sprintf(concatpath, "%s%s", base, path);
2946        one = alloc_filespec(concatpath);
2947        two = alloc_filespec(concatpath);
2948        fill_filespec(one, old_sha1, old_mode);
2949        fill_filespec(two, new_sha1, new_mode);
2950
2951        diff_queue(&diff_queued_diff, one, two);
2952}
2953
2954void diff_unmerge(struct diff_options *options,
2955                  const char *path,
2956                  unsigned mode, const unsigned char *sha1)
2957{
2958        struct diff_filespec *one, *two;
2959        one = alloc_filespec(path);
2960        two = alloc_filespec(path);
2961        fill_filespec(one, sha1, mode);
2962        diff_queue(&diff_queued_diff, one, two)->is_unmerged = 1;
2963}