edf16a39af464b3db466e230ef0291768b25a0d5
   1/*
   2 * Copyright (C) 2005 Junio C Hamano
   3 */
   4#include "cache.h"
   5#include "tempfile.h"
   6#include "quote.h"
   7#include "diff.h"
   8#include "diffcore.h"
   9#include "delta.h"
  10#include "xdiff-interface.h"
  11#include "color.h"
  12#include "attr.h"
  13#include "run-command.h"
  14#include "utf8.h"
  15#include "userdiff.h"
  16#include "submodule-config.h"
  17#include "submodule.h"
  18#include "ll-merge.h"
  19#include "string-list.h"
  20#include "argv-array.h"
  21
  22#ifdef NO_FAST_WORKING_DIRECTORY
  23#define FAST_WORKING_DIRECTORY 0
  24#else
  25#define FAST_WORKING_DIRECTORY 1
  26#endif
  27
  28static int diff_detect_rename_default;
  29static int diff_indent_heuristic; /* experimental */
  30static int diff_compaction_heuristic; /* experimental */
  31static int diff_rename_limit_default = 400;
  32static int diff_suppress_blank_empty;
  33static int diff_use_color_default = -1;
  34static int diff_context_default = 3;
  35static const char *diff_word_regex_cfg;
  36static const char *external_diff_cmd_cfg;
  37static const char *diff_order_file_cfg;
  38int diff_auto_refresh_index = 1;
  39static int diff_mnemonic_prefix;
  40static int diff_no_prefix;
  41static int diff_stat_graph_width;
  42static int diff_dirstat_permille_default = 30;
  43static struct diff_options default_diff_options;
  44static long diff_algorithm;
  45
  46static char diff_colors[][COLOR_MAXLEN] = {
  47        GIT_COLOR_RESET,
  48        GIT_COLOR_NORMAL,       /* CONTEXT */
  49        GIT_COLOR_BOLD,         /* METAINFO */
  50        GIT_COLOR_CYAN,         /* FRAGINFO */
  51        GIT_COLOR_RED,          /* OLD */
  52        GIT_COLOR_GREEN,        /* NEW */
  53        GIT_COLOR_YELLOW,       /* COMMIT */
  54        GIT_COLOR_BG_RED,       /* WHITESPACE */
  55        GIT_COLOR_NORMAL,       /* FUNCINFO */
  56};
  57
  58static int parse_diff_color_slot(const char *var)
  59{
  60        if (!strcasecmp(var, "context") || !strcasecmp(var, "plain"))
  61                return DIFF_CONTEXT;
  62        if (!strcasecmp(var, "meta"))
  63                return DIFF_METAINFO;
  64        if (!strcasecmp(var, "frag"))
  65                return DIFF_FRAGINFO;
  66        if (!strcasecmp(var, "old"))
  67                return DIFF_FILE_OLD;
  68        if (!strcasecmp(var, "new"))
  69                return DIFF_FILE_NEW;
  70        if (!strcasecmp(var, "commit"))
  71                return DIFF_COMMIT;
  72        if (!strcasecmp(var, "whitespace"))
  73                return DIFF_WHITESPACE;
  74        if (!strcasecmp(var, "func"))
  75                return DIFF_FUNCINFO;
  76        return -1;
  77}
  78
  79static int parse_dirstat_params(struct diff_options *options, const char *params_string,
  80                                struct strbuf *errmsg)
  81{
  82        char *params_copy = xstrdup(params_string);
  83        struct string_list params = STRING_LIST_INIT_NODUP;
  84        int ret = 0;
  85        int i;
  86
  87        if (*params_copy)
  88                string_list_split_in_place(&params, params_copy, ',', -1);
  89        for (i = 0; i < params.nr; i++) {
  90                const char *p = params.items[i].string;
  91                if (!strcmp(p, "changes")) {
  92                        DIFF_OPT_CLR(options, DIRSTAT_BY_LINE);
  93                        DIFF_OPT_CLR(options, DIRSTAT_BY_FILE);
  94                } else if (!strcmp(p, "lines")) {
  95                        DIFF_OPT_SET(options, DIRSTAT_BY_LINE);
  96                        DIFF_OPT_CLR(options, DIRSTAT_BY_FILE);
  97                } else if (!strcmp(p, "files")) {
  98                        DIFF_OPT_CLR(options, DIRSTAT_BY_LINE);
  99                        DIFF_OPT_SET(options, DIRSTAT_BY_FILE);
 100                } else if (!strcmp(p, "noncumulative")) {
 101                        DIFF_OPT_CLR(options, DIRSTAT_CUMULATIVE);
 102                } else if (!strcmp(p, "cumulative")) {
 103                        DIFF_OPT_SET(options, DIRSTAT_CUMULATIVE);
 104                } else if (isdigit(*p)) {
 105                        char *end;
 106                        int permille = strtoul(p, &end, 10) * 10;
 107                        if (*end == '.' && isdigit(*++end)) {
 108                                /* only use first digit */
 109                                permille += *end - '0';
 110                                /* .. and ignore any further digits */
 111                                while (isdigit(*++end))
 112                                        ; /* nothing */
 113                        }
 114                        if (!*end)
 115                                options->dirstat_permille = permille;
 116                        else {
 117                                strbuf_addf(errmsg, _("  Failed to parse dirstat cut-off percentage '%s'\n"),
 118                                            p);
 119                                ret++;
 120                        }
 121                } else {
 122                        strbuf_addf(errmsg, _("  Unknown dirstat parameter '%s'\n"), p);
 123                        ret++;
 124                }
 125
 126        }
 127        string_list_clear(&params, 0);
 128        free(params_copy);
 129        return ret;
 130}
 131
 132static int parse_submodule_params(struct diff_options *options, const char *value)
 133{
 134        if (!strcmp(value, "log"))
 135                DIFF_OPT_SET(options, SUBMODULE_LOG);
 136        else if (!strcmp(value, "short"))
 137                DIFF_OPT_CLR(options, SUBMODULE_LOG);
 138        else
 139                return -1;
 140        return 0;
 141}
 142
 143static int git_config_rename(const char *var, const char *value)
 144{
 145        if (!value)
 146                return DIFF_DETECT_RENAME;
 147        if (!strcasecmp(value, "copies") || !strcasecmp(value, "copy"))
 148                return  DIFF_DETECT_COPY;
 149        return git_config_bool(var,value) ? DIFF_DETECT_RENAME : 0;
 150}
 151
 152long parse_algorithm_value(const char *value)
 153{
 154        if (!value)
 155                return -1;
 156        else if (!strcasecmp(value, "myers") || !strcasecmp(value, "default"))
 157                return 0;
 158        else if (!strcasecmp(value, "minimal"))
 159                return XDF_NEED_MINIMAL;
 160        else if (!strcasecmp(value, "patience"))
 161                return XDF_PATIENCE_DIFF;
 162        else if (!strcasecmp(value, "histogram"))
 163                return XDF_HISTOGRAM_DIFF;
 164        return -1;
 165}
 166
 167/*
 168 * These are to give UI layer defaults.
 169 * The core-level commands such as git-diff-files should
 170 * never be affected by the setting of diff.renames
 171 * the user happens to have in the configuration file.
 172 */
 173void init_diff_ui_defaults(void)
 174{
 175        diff_detect_rename_default = 1;
 176}
 177
 178int git_diff_ui_config(const char *var, const char *value, void *cb)
 179{
 180        if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff")) {
 181                diff_use_color_default = git_config_colorbool(var, value);
 182                return 0;
 183        }
 184        if (!strcmp(var, "diff.context")) {
 185                diff_context_default = git_config_int(var, value);
 186                if (diff_context_default < 0)
 187                        return -1;
 188                return 0;
 189        }
 190        if (!strcmp(var, "diff.renames")) {
 191                diff_detect_rename_default = git_config_rename(var, value);
 192                return 0;
 193        }
 194        if (!strcmp(var, "diff.indentheuristic")) {
 195                diff_indent_heuristic = git_config_bool(var, value);
 196                if (diff_indent_heuristic)
 197                        diff_compaction_heuristic = 0;
 198                return 0;
 199        }
 200        if (!strcmp(var, "diff.compactionheuristic")) {
 201                diff_compaction_heuristic = git_config_bool(var, value);
 202                if (diff_compaction_heuristic)
 203                        diff_indent_heuristic = 0;
 204                return 0;
 205        }
 206        if (!strcmp(var, "diff.autorefreshindex")) {
 207                diff_auto_refresh_index = git_config_bool(var, value);
 208                return 0;
 209        }
 210        if (!strcmp(var, "diff.mnemonicprefix")) {
 211                diff_mnemonic_prefix = git_config_bool(var, value);
 212                return 0;
 213        }
 214        if (!strcmp(var, "diff.noprefix")) {
 215                diff_no_prefix = git_config_bool(var, value);
 216                return 0;
 217        }
 218        if (!strcmp(var, "diff.statgraphwidth")) {
 219                diff_stat_graph_width = git_config_int(var, value);
 220                return 0;
 221        }
 222        if (!strcmp(var, "diff.external"))
 223                return git_config_string(&external_diff_cmd_cfg, var, value);
 224        if (!strcmp(var, "diff.wordregex"))
 225                return git_config_string(&diff_word_regex_cfg, var, value);
 226        if (!strcmp(var, "diff.orderfile"))
 227                return git_config_pathname(&diff_order_file_cfg, var, value);
 228
 229        if (!strcmp(var, "diff.ignoresubmodules"))
 230                handle_ignore_submodules_arg(&default_diff_options, value);
 231
 232        if (!strcmp(var, "diff.submodule")) {
 233                if (parse_submodule_params(&default_diff_options, value))
 234                        warning(_("Unknown value for 'diff.submodule' config variable: '%s'"),
 235                                value);
 236                return 0;
 237        }
 238
 239        if (!strcmp(var, "diff.algorithm")) {
 240                diff_algorithm = parse_algorithm_value(value);
 241                if (diff_algorithm < 0)
 242                        return -1;
 243                return 0;
 244        }
 245
 246        if (git_color_config(var, value, cb) < 0)
 247                return -1;
 248
 249        return git_diff_basic_config(var, value, cb);
 250}
 251
 252int git_diff_basic_config(const char *var, const char *value, void *cb)
 253{
 254        const char *name;
 255
 256        if (!strcmp(var, "diff.renamelimit")) {
 257                diff_rename_limit_default = git_config_int(var, value);
 258                return 0;
 259        }
 260
 261        if (userdiff_config(var, value) < 0)
 262                return -1;
 263
 264        if (skip_prefix(var, "diff.color.", &name) ||
 265            skip_prefix(var, "color.diff.", &name)) {
 266                int slot = parse_diff_color_slot(name);
 267                if (slot < 0)
 268                        return 0;
 269                if (!value)
 270                        return config_error_nonbool(var);
 271                return color_parse(value, diff_colors[slot]);
 272        }
 273
 274        /* like GNU diff's --suppress-blank-empty option  */
 275        if (!strcmp(var, "diff.suppressblankempty") ||
 276                        /* for backwards compatibility */
 277                        !strcmp(var, "diff.suppress-blank-empty")) {
 278                diff_suppress_blank_empty = git_config_bool(var, value);
 279                return 0;
 280        }
 281
 282        if (!strcmp(var, "diff.dirstat")) {
 283                struct strbuf errmsg = STRBUF_INIT;
 284                default_diff_options.dirstat_permille = diff_dirstat_permille_default;
 285                if (parse_dirstat_params(&default_diff_options, value, &errmsg))
 286                        warning(_("Found errors in 'diff.dirstat' config variable:\n%s"),
 287                                errmsg.buf);
 288                strbuf_release(&errmsg);
 289                diff_dirstat_permille_default = default_diff_options.dirstat_permille;
 290                return 0;
 291        }
 292
 293        if (starts_with(var, "submodule."))
 294                return parse_submodule_config_option(var, value);
 295
 296        return git_default_config(var, value, cb);
 297}
 298
 299static char *quote_two(const char *one, const char *two)
 300{
 301        int need_one = quote_c_style(one, NULL, NULL, 1);
 302        int need_two = quote_c_style(two, NULL, NULL, 1);
 303        struct strbuf res = STRBUF_INIT;
 304
 305        if (need_one + need_two) {
 306                strbuf_addch(&res, '"');
 307                quote_c_style(one, &res, NULL, 1);
 308                quote_c_style(two, &res, NULL, 1);
 309                strbuf_addch(&res, '"');
 310        } else {
 311                strbuf_addstr(&res, one);
 312                strbuf_addstr(&res, two);
 313        }
 314        return strbuf_detach(&res, NULL);
 315}
 316
 317static const char *external_diff(void)
 318{
 319        static const char *external_diff_cmd = NULL;
 320        static int done_preparing = 0;
 321
 322        if (done_preparing)
 323                return external_diff_cmd;
 324        external_diff_cmd = getenv("GIT_EXTERNAL_DIFF");
 325        if (!external_diff_cmd)
 326                external_diff_cmd = external_diff_cmd_cfg;
 327        done_preparing = 1;
 328        return external_diff_cmd;
 329}
 330
 331/*
 332 * Keep track of files used for diffing. Sometimes such an entry
 333 * refers to a temporary file, sometimes to an existing file, and
 334 * sometimes to "/dev/null".
 335 */
 336static struct diff_tempfile {
 337        /*
 338         * filename external diff should read from, or NULL if this
 339         * entry is currently not in use:
 340         */
 341        const char *name;
 342
 343        char hex[GIT_SHA1_HEXSZ + 1];
 344        char mode[10];
 345
 346        /*
 347         * If this diff_tempfile instance refers to a temporary file,
 348         * this tempfile object is used to manage its lifetime.
 349         */
 350        struct tempfile tempfile;
 351} diff_temp[2];
 352
 353typedef unsigned long (*sane_truncate_fn)(char *line, unsigned long len);
 354
 355struct emit_callback {
 356        int color_diff;
 357        unsigned ws_rule;
 358        int blank_at_eof_in_preimage;
 359        int blank_at_eof_in_postimage;
 360        int lno_in_preimage;
 361        int lno_in_postimage;
 362        sane_truncate_fn truncate;
 363        const char **label_path;
 364        struct diff_words_data *diff_words;
 365        struct diff_options *opt;
 366        int *found_changesp;
 367        struct strbuf *header;
 368};
 369
 370static int count_lines(const char *data, int size)
 371{
 372        int count, ch, completely_empty = 1, nl_just_seen = 0;
 373        count = 0;
 374        while (0 < size--) {
 375                ch = *data++;
 376                if (ch == '\n') {
 377                        count++;
 378                        nl_just_seen = 1;
 379                        completely_empty = 0;
 380                }
 381                else {
 382                        nl_just_seen = 0;
 383                        completely_empty = 0;
 384                }
 385        }
 386        if (completely_empty)
 387                return 0;
 388        if (!nl_just_seen)
 389                count++; /* no trailing newline */
 390        return count;
 391}
 392
 393static int fill_mmfile(mmfile_t *mf, struct diff_filespec *one)
 394{
 395        if (!DIFF_FILE_VALID(one)) {
 396                mf->ptr = (char *)""; /* does not matter */
 397                mf->size = 0;
 398                return 0;
 399        }
 400        else if (diff_populate_filespec(one, 0))
 401                return -1;
 402
 403        mf->ptr = one->data;
 404        mf->size = one->size;
 405        return 0;
 406}
 407
 408/* like fill_mmfile, but only for size, so we can avoid retrieving blob */
 409static unsigned long diff_filespec_size(struct diff_filespec *one)
 410{
 411        if (!DIFF_FILE_VALID(one))
 412                return 0;
 413        diff_populate_filespec(one, CHECK_SIZE_ONLY);
 414        return one->size;
 415}
 416
 417static int count_trailing_blank(mmfile_t *mf, unsigned ws_rule)
 418{
 419        char *ptr = mf->ptr;
 420        long size = mf->size;
 421        int cnt = 0;
 422
 423        if (!size)
 424                return cnt;
 425        ptr += size - 1; /* pointing at the very end */
 426        if (*ptr != '\n')
 427                ; /* incomplete line */
 428        else
 429                ptr--; /* skip the last LF */
 430        while (mf->ptr < ptr) {
 431                char *prev_eol;
 432                for (prev_eol = ptr; mf->ptr <= prev_eol; prev_eol--)
 433                        if (*prev_eol == '\n')
 434                                break;
 435                if (!ws_blank_line(prev_eol + 1, ptr - prev_eol, ws_rule))
 436                        break;
 437                cnt++;
 438                ptr = prev_eol - 1;
 439        }
 440        return cnt;
 441}
 442
 443static void check_blank_at_eof(mmfile_t *mf1, mmfile_t *mf2,
 444                               struct emit_callback *ecbdata)
 445{
 446        int l1, l2, at;
 447        unsigned ws_rule = ecbdata->ws_rule;
 448        l1 = count_trailing_blank(mf1, ws_rule);
 449        l2 = count_trailing_blank(mf2, ws_rule);
 450        if (l2 <= l1) {
 451                ecbdata->blank_at_eof_in_preimage = 0;
 452                ecbdata->blank_at_eof_in_postimage = 0;
 453                return;
 454        }
 455        at = count_lines(mf1->ptr, mf1->size);
 456        ecbdata->blank_at_eof_in_preimage = (at - l1) + 1;
 457
 458        at = count_lines(mf2->ptr, mf2->size);
 459        ecbdata->blank_at_eof_in_postimage = (at - l2) + 1;
 460}
 461
 462static void emit_line_0(struct diff_options *o, const char *set, const char *reset,
 463                        int first, const char *line, int len)
 464{
 465        int has_trailing_newline, has_trailing_carriage_return;
 466        int nofirst;
 467        FILE *file = o->file;
 468
 469        fputs(diff_line_prefix(o), file);
 470
 471        if (len == 0) {
 472                has_trailing_newline = (first == '\n');
 473                has_trailing_carriage_return = (!has_trailing_newline &&
 474                                                (first == '\r'));
 475                nofirst = has_trailing_newline || has_trailing_carriage_return;
 476        } else {
 477                has_trailing_newline = (len > 0 && line[len-1] == '\n');
 478                if (has_trailing_newline)
 479                        len--;
 480                has_trailing_carriage_return = (len > 0 && line[len-1] == '\r');
 481                if (has_trailing_carriage_return)
 482                        len--;
 483                nofirst = 0;
 484        }
 485
 486        if (len || !nofirst) {
 487                fputs(set, file);
 488                if (!nofirst)
 489                        fputc(first, file);
 490                fwrite(line, len, 1, file);
 491                fputs(reset, file);
 492        }
 493        if (has_trailing_carriage_return)
 494                fputc('\r', file);
 495        if (has_trailing_newline)
 496                fputc('\n', file);
 497}
 498
 499static void emit_line(struct diff_options *o, const char *set, const char *reset,
 500                      const char *line, int len)
 501{
 502        emit_line_0(o, set, reset, line[0], line+1, len-1);
 503}
 504
 505static int new_blank_line_at_eof(struct emit_callback *ecbdata, const char *line, int len)
 506{
 507        if (!((ecbdata->ws_rule & WS_BLANK_AT_EOF) &&
 508              ecbdata->blank_at_eof_in_preimage &&
 509              ecbdata->blank_at_eof_in_postimage &&
 510              ecbdata->blank_at_eof_in_preimage <= ecbdata->lno_in_preimage &&
 511              ecbdata->blank_at_eof_in_postimage <= ecbdata->lno_in_postimage))
 512                return 0;
 513        return ws_blank_line(line, len, ecbdata->ws_rule);
 514}
 515
 516static void emit_line_checked(const char *reset,
 517                              struct emit_callback *ecbdata,
 518                              const char *line, int len,
 519                              enum color_diff color,
 520                              unsigned ws_error_highlight,
 521                              char sign)
 522{
 523        const char *set = diff_get_color(ecbdata->color_diff, color);
 524        const char *ws = NULL;
 525
 526        if (ecbdata->opt->ws_error_highlight & ws_error_highlight) {
 527                ws = diff_get_color(ecbdata->color_diff, DIFF_WHITESPACE);
 528                if (!*ws)
 529                        ws = NULL;
 530        }
 531
 532        if (!ws)
 533                emit_line_0(ecbdata->opt, set, reset, sign, line, len);
 534        else if (sign == '+' && new_blank_line_at_eof(ecbdata, line, len))
 535                /* Blank line at EOF - paint '+' as well */
 536                emit_line_0(ecbdata->opt, ws, reset, sign, line, len);
 537        else {
 538                /* Emit just the prefix, then the rest. */
 539                emit_line_0(ecbdata->opt, set, reset, sign, "", 0);
 540                ws_check_emit(line, len, ecbdata->ws_rule,
 541                              ecbdata->opt->file, set, reset, ws);
 542        }
 543}
 544
 545static void emit_add_line(const char *reset,
 546                          struct emit_callback *ecbdata,
 547                          const char *line, int len)
 548{
 549        emit_line_checked(reset, ecbdata, line, len,
 550                          DIFF_FILE_NEW, WSEH_NEW, '+');
 551}
 552
 553static void emit_del_line(const char *reset,
 554                          struct emit_callback *ecbdata,
 555                          const char *line, int len)
 556{
 557        emit_line_checked(reset, ecbdata, line, len,
 558                          DIFF_FILE_OLD, WSEH_OLD, '-');
 559}
 560
 561static void emit_context_line(const char *reset,
 562                              struct emit_callback *ecbdata,
 563                              const char *line, int len)
 564{
 565        emit_line_checked(reset, ecbdata, line, len,
 566                          DIFF_CONTEXT, WSEH_CONTEXT, ' ');
 567}
 568
 569static void emit_hunk_header(struct emit_callback *ecbdata,
 570                             const char *line, int len)
 571{
 572        const char *context = diff_get_color(ecbdata->color_diff, DIFF_CONTEXT);
 573        const char *frag = diff_get_color(ecbdata->color_diff, DIFF_FRAGINFO);
 574        const char *func = diff_get_color(ecbdata->color_diff, DIFF_FUNCINFO);
 575        const char *reset = diff_get_color(ecbdata->color_diff, DIFF_RESET);
 576        static const char atat[2] = { '@', '@' };
 577        const char *cp, *ep;
 578        struct strbuf msgbuf = STRBUF_INIT;
 579        int org_len = len;
 580        int i = 1;
 581
 582        /*
 583         * As a hunk header must begin with "@@ -<old>, +<new> @@",
 584         * it always is at least 10 bytes long.
 585         */
 586        if (len < 10 ||
 587            memcmp(line, atat, 2) ||
 588            !(ep = memmem(line + 2, len - 2, atat, 2))) {
 589                emit_line(ecbdata->opt, context, reset, line, len);
 590                return;
 591        }
 592        ep += 2; /* skip over @@ */
 593
 594        /* The hunk header in fraginfo color */
 595        strbuf_addstr(&msgbuf, frag);
 596        strbuf_add(&msgbuf, line, ep - line);
 597        strbuf_addstr(&msgbuf, reset);
 598
 599        /*
 600         * trailing "\r\n"
 601         */
 602        for ( ; i < 3; i++)
 603                if (line[len - i] == '\r' || line[len - i] == '\n')
 604                        len--;
 605
 606        /* blank before the func header */
 607        for (cp = ep; ep - line < len; ep++)
 608                if (*ep != ' ' && *ep != '\t')
 609                        break;
 610        if (ep != cp) {
 611                strbuf_addstr(&msgbuf, context);
 612                strbuf_add(&msgbuf, cp, ep - cp);
 613                strbuf_addstr(&msgbuf, reset);
 614        }
 615
 616        if (ep < line + len) {
 617                strbuf_addstr(&msgbuf, func);
 618                strbuf_add(&msgbuf, ep, line + len - ep);
 619                strbuf_addstr(&msgbuf, reset);
 620        }
 621
 622        strbuf_add(&msgbuf, line + len, org_len - len);
 623        emit_line(ecbdata->opt, "", "", msgbuf.buf, msgbuf.len);
 624        strbuf_release(&msgbuf);
 625}
 626
 627static struct diff_tempfile *claim_diff_tempfile(void) {
 628        int i;
 629        for (i = 0; i < ARRAY_SIZE(diff_temp); i++)
 630                if (!diff_temp[i].name)
 631                        return diff_temp + i;
 632        die("BUG: diff is failing to clean up its tempfiles");
 633}
 634
 635static void remove_tempfile(void)
 636{
 637        int i;
 638        for (i = 0; i < ARRAY_SIZE(diff_temp); i++) {
 639                if (is_tempfile_active(&diff_temp[i].tempfile))
 640                        delete_tempfile(&diff_temp[i].tempfile);
 641                diff_temp[i].name = NULL;
 642        }
 643}
 644
 645static void print_line_count(FILE *file, int count)
 646{
 647        switch (count) {
 648        case 0:
 649                fprintf(file, "0,0");
 650                break;
 651        case 1:
 652                fprintf(file, "1");
 653                break;
 654        default:
 655                fprintf(file, "1,%d", count);
 656                break;
 657        }
 658}
 659
 660static void emit_rewrite_lines(struct emit_callback *ecb,
 661                               int prefix, const char *data, int size)
 662{
 663        const char *endp = NULL;
 664        static const char *nneof = " No newline at end of file\n";
 665        const char *reset = diff_get_color(ecb->color_diff, DIFF_RESET);
 666
 667        while (0 < size) {
 668                int len;
 669
 670                endp = memchr(data, '\n', size);
 671                len = endp ? (endp - data + 1) : size;
 672                if (prefix != '+') {
 673                        ecb->lno_in_preimage++;
 674                        emit_del_line(reset, ecb, data, len);
 675                } else {
 676                        ecb->lno_in_postimage++;
 677                        emit_add_line(reset, ecb, data, len);
 678                }
 679                size -= len;
 680                data += len;
 681        }
 682        if (!endp) {
 683                const char *context = diff_get_color(ecb->color_diff,
 684                                                     DIFF_CONTEXT);
 685                putc('\n', ecb->opt->file);
 686                emit_line_0(ecb->opt, context, reset, '\\',
 687                            nneof, strlen(nneof));
 688        }
 689}
 690
 691static void emit_rewrite_diff(const char *name_a,
 692                              const char *name_b,
 693                              struct diff_filespec *one,
 694                              struct diff_filespec *two,
 695                              struct userdiff_driver *textconv_one,
 696                              struct userdiff_driver *textconv_two,
 697                              struct diff_options *o)
 698{
 699        int lc_a, lc_b;
 700        const char *name_a_tab, *name_b_tab;
 701        const char *metainfo = diff_get_color(o->use_color, DIFF_METAINFO);
 702        const char *fraginfo = diff_get_color(o->use_color, DIFF_FRAGINFO);
 703        const char *reset = diff_get_color(o->use_color, DIFF_RESET);
 704        static struct strbuf a_name = STRBUF_INIT, b_name = STRBUF_INIT;
 705        const char *a_prefix, *b_prefix;
 706        char *data_one, *data_two;
 707        size_t size_one, size_two;
 708        struct emit_callback ecbdata;
 709        const char *line_prefix = diff_line_prefix(o);
 710
 711        if (diff_mnemonic_prefix && DIFF_OPT_TST(o, REVERSE_DIFF)) {
 712                a_prefix = o->b_prefix;
 713                b_prefix = o->a_prefix;
 714        } else {
 715                a_prefix = o->a_prefix;
 716                b_prefix = o->b_prefix;
 717        }
 718
 719        name_a += (*name_a == '/');
 720        name_b += (*name_b == '/');
 721        name_a_tab = strchr(name_a, ' ') ? "\t" : "";
 722        name_b_tab = strchr(name_b, ' ') ? "\t" : "";
 723
 724        strbuf_reset(&a_name);
 725        strbuf_reset(&b_name);
 726        quote_two_c_style(&a_name, a_prefix, name_a, 0);
 727        quote_two_c_style(&b_name, b_prefix, name_b, 0);
 728
 729        size_one = fill_textconv(textconv_one, one, &data_one);
 730        size_two = fill_textconv(textconv_two, two, &data_two);
 731
 732        memset(&ecbdata, 0, sizeof(ecbdata));
 733        ecbdata.color_diff = want_color(o->use_color);
 734        ecbdata.found_changesp = &o->found_changes;
 735        ecbdata.ws_rule = whitespace_rule(name_b);
 736        ecbdata.opt = o;
 737        if (ecbdata.ws_rule & WS_BLANK_AT_EOF) {
 738                mmfile_t mf1, mf2;
 739                mf1.ptr = (char *)data_one;
 740                mf2.ptr = (char *)data_two;
 741                mf1.size = size_one;
 742                mf2.size = size_two;
 743                check_blank_at_eof(&mf1, &mf2, &ecbdata);
 744        }
 745        ecbdata.lno_in_preimage = 1;
 746        ecbdata.lno_in_postimage = 1;
 747
 748        lc_a = count_lines(data_one, size_one);
 749        lc_b = count_lines(data_two, size_two);
 750        fprintf(o->file,
 751                "%s%s--- %s%s%s\n%s%s+++ %s%s%s\n%s%s@@ -",
 752                line_prefix, metainfo, a_name.buf, name_a_tab, reset,
 753                line_prefix, metainfo, b_name.buf, name_b_tab, reset,
 754                line_prefix, fraginfo);
 755        if (!o->irreversible_delete)
 756                print_line_count(o->file, lc_a);
 757        else
 758                fprintf(o->file, "?,?");
 759        fprintf(o->file, " +");
 760        print_line_count(o->file, lc_b);
 761        fprintf(o->file, " @@%s\n", reset);
 762        if (lc_a && !o->irreversible_delete)
 763                emit_rewrite_lines(&ecbdata, '-', data_one, size_one);
 764        if (lc_b)
 765                emit_rewrite_lines(&ecbdata, '+', data_two, size_two);
 766        if (textconv_one)
 767                free((char *)data_one);
 768        if (textconv_two)
 769                free((char *)data_two);
 770}
 771
 772struct diff_words_buffer {
 773        mmfile_t text;
 774        long alloc;
 775        struct diff_words_orig {
 776                const char *begin, *end;
 777        } *orig;
 778        int orig_nr, orig_alloc;
 779};
 780
 781static void diff_words_append(char *line, unsigned long len,
 782                struct diff_words_buffer *buffer)
 783{
 784        ALLOC_GROW(buffer->text.ptr, buffer->text.size + len, buffer->alloc);
 785        line++;
 786        len--;
 787        memcpy(buffer->text.ptr + buffer->text.size, line, len);
 788        buffer->text.size += len;
 789        buffer->text.ptr[buffer->text.size] = '\0';
 790}
 791
 792struct diff_words_style_elem {
 793        const char *prefix;
 794        const char *suffix;
 795        const char *color; /* NULL; filled in by the setup code if
 796                            * color is enabled */
 797};
 798
 799struct diff_words_style {
 800        enum diff_words_type type;
 801        struct diff_words_style_elem new, old, ctx;
 802        const char *newline;
 803};
 804
 805static struct diff_words_style diff_words_styles[] = {
 806        { DIFF_WORDS_PORCELAIN, {"+", "\n"}, {"-", "\n"}, {" ", "\n"}, "~\n" },
 807        { DIFF_WORDS_PLAIN, {"{+", "+}"}, {"[-", "-]"}, {"", ""}, "\n" },
 808        { DIFF_WORDS_COLOR, {"", ""}, {"", ""}, {"", ""}, "\n" }
 809};
 810
 811struct diff_words_data {
 812        struct diff_words_buffer minus, plus;
 813        const char *current_plus;
 814        int last_minus;
 815        struct diff_options *opt;
 816        regex_t *word_regex;
 817        enum diff_words_type type;
 818        struct diff_words_style *style;
 819};
 820
 821static int fn_out_diff_words_write_helper(FILE *fp,
 822                                          struct diff_words_style_elem *st_el,
 823                                          const char *newline,
 824                                          size_t count, const char *buf,
 825                                          const char *line_prefix)
 826{
 827        int print = 0;
 828
 829        while (count) {
 830                char *p = memchr(buf, '\n', count);
 831                if (print)
 832                        fputs(line_prefix, fp);
 833                if (p != buf) {
 834                        if (st_el->color && fputs(st_el->color, fp) < 0)
 835                                return -1;
 836                        if (fputs(st_el->prefix, fp) < 0 ||
 837                            fwrite(buf, p ? p - buf : count, 1, fp) != 1 ||
 838                            fputs(st_el->suffix, fp) < 0)
 839                                return -1;
 840                        if (st_el->color && *st_el->color
 841                            && fputs(GIT_COLOR_RESET, fp) < 0)
 842                                return -1;
 843                }
 844                if (!p)
 845                        return 0;
 846                if (fputs(newline, fp) < 0)
 847                        return -1;
 848                count -= p + 1 - buf;
 849                buf = p + 1;
 850                print = 1;
 851        }
 852        return 0;
 853}
 854
 855/*
 856 * '--color-words' algorithm can be described as:
 857 *
 858 *   1. collect a the minus/plus lines of a diff hunk, divided into
 859 *      minus-lines and plus-lines;
 860 *
 861 *   2. break both minus-lines and plus-lines into words and
 862 *      place them into two mmfile_t with one word for each line;
 863 *
 864 *   3. use xdiff to run diff on the two mmfile_t to get the words level diff;
 865 *
 866 * And for the common parts of the both file, we output the plus side text.
 867 * diff_words->current_plus is used to trace the current position of the plus file
 868 * which printed. diff_words->last_minus is used to trace the last minus word
 869 * printed.
 870 *
 871 * For '--graph' to work with '--color-words', we need to output the graph prefix
 872 * on each line of color words output. Generally, there are two conditions on
 873 * which we should output the prefix.
 874 *
 875 *   1. diff_words->last_minus == 0 &&
 876 *      diff_words->current_plus == diff_words->plus.text.ptr
 877 *
 878 *      that is: the plus text must start as a new line, and if there is no minus
 879 *      word printed, a graph prefix must be printed.
 880 *
 881 *   2. diff_words->current_plus > diff_words->plus.text.ptr &&
 882 *      *(diff_words->current_plus - 1) == '\n'
 883 *
 884 *      that is: a graph prefix must be printed following a '\n'
 885 */
 886static int color_words_output_graph_prefix(struct diff_words_data *diff_words)
 887{
 888        if ((diff_words->last_minus == 0 &&
 889                diff_words->current_plus == diff_words->plus.text.ptr) ||
 890                (diff_words->current_plus > diff_words->plus.text.ptr &&
 891                *(diff_words->current_plus - 1) == '\n')) {
 892                return 1;
 893        } else {
 894                return 0;
 895        }
 896}
 897
 898static void fn_out_diff_words_aux(void *priv, char *line, unsigned long len)
 899{
 900        struct diff_words_data *diff_words = priv;
 901        struct diff_words_style *style = diff_words->style;
 902        int minus_first, minus_len, plus_first, plus_len;
 903        const char *minus_begin, *minus_end, *plus_begin, *plus_end;
 904        struct diff_options *opt = diff_words->opt;
 905        const char *line_prefix;
 906
 907        if (line[0] != '@' || parse_hunk_header(line, len,
 908                        &minus_first, &minus_len, &plus_first, &plus_len))
 909                return;
 910
 911        assert(opt);
 912        line_prefix = diff_line_prefix(opt);
 913
 914        /* POSIX requires that first be decremented by one if len == 0... */
 915        if (minus_len) {
 916                minus_begin = diff_words->minus.orig[minus_first].begin;
 917                minus_end =
 918                        diff_words->minus.orig[minus_first + minus_len - 1].end;
 919        } else
 920                minus_begin = minus_end =
 921                        diff_words->minus.orig[minus_first].end;
 922
 923        if (plus_len) {
 924                plus_begin = diff_words->plus.orig[plus_first].begin;
 925                plus_end = diff_words->plus.orig[plus_first + plus_len - 1].end;
 926        } else
 927                plus_begin = plus_end = diff_words->plus.orig[plus_first].end;
 928
 929        if (color_words_output_graph_prefix(diff_words)) {
 930                fputs(line_prefix, diff_words->opt->file);
 931        }
 932        if (diff_words->current_plus != plus_begin) {
 933                fn_out_diff_words_write_helper(diff_words->opt->file,
 934                                &style->ctx, style->newline,
 935                                plus_begin - diff_words->current_plus,
 936                                diff_words->current_plus, line_prefix);
 937                if (*(plus_begin - 1) == '\n')
 938                        fputs(line_prefix, diff_words->opt->file);
 939        }
 940        if (minus_begin != minus_end) {
 941                fn_out_diff_words_write_helper(diff_words->opt->file,
 942                                &style->old, style->newline,
 943                                minus_end - minus_begin, minus_begin,
 944                                line_prefix);
 945        }
 946        if (plus_begin != plus_end) {
 947                fn_out_diff_words_write_helper(diff_words->opt->file,
 948                                &style->new, style->newline,
 949                                plus_end - plus_begin, plus_begin,
 950                                line_prefix);
 951        }
 952
 953        diff_words->current_plus = plus_end;
 954        diff_words->last_minus = minus_first;
 955}
 956
 957/* This function starts looking at *begin, and returns 0 iff a word was found. */
 958static int find_word_boundaries(mmfile_t *buffer, regex_t *word_regex,
 959                int *begin, int *end)
 960{
 961        if (word_regex && *begin < buffer->size) {
 962                regmatch_t match[1];
 963                if (!regexec(word_regex, buffer->ptr + *begin, 1, match, 0)) {
 964                        char *p = memchr(buffer->ptr + *begin + match[0].rm_so,
 965                                        '\n', match[0].rm_eo - match[0].rm_so);
 966                        *end = p ? p - buffer->ptr : match[0].rm_eo + *begin;
 967                        *begin += match[0].rm_so;
 968                        return *begin >= *end;
 969                }
 970                return -1;
 971        }
 972
 973        /* find the next word */
 974        while (*begin < buffer->size && isspace(buffer->ptr[*begin]))
 975                (*begin)++;
 976        if (*begin >= buffer->size)
 977                return -1;
 978
 979        /* find the end of the word */
 980        *end = *begin + 1;
 981        while (*end < buffer->size && !isspace(buffer->ptr[*end]))
 982                (*end)++;
 983
 984        return 0;
 985}
 986
 987/*
 988 * This function splits the words in buffer->text, stores the list with
 989 * newline separator into out, and saves the offsets of the original words
 990 * in buffer->orig.
 991 */
 992static void diff_words_fill(struct diff_words_buffer *buffer, mmfile_t *out,
 993                regex_t *word_regex)
 994{
 995        int i, j;
 996        long alloc = 0;
 997
 998        out->size = 0;
 999        out->ptr = NULL;
1000
1001        /* fake an empty "0th" word */
1002        ALLOC_GROW(buffer->orig, 1, buffer->orig_alloc);
1003        buffer->orig[0].begin = buffer->orig[0].end = buffer->text.ptr;
1004        buffer->orig_nr = 1;
1005
1006        for (i = 0; i < buffer->text.size; i++) {
1007                if (find_word_boundaries(&buffer->text, word_regex, &i, &j))
1008                        return;
1009
1010                /* store original boundaries */
1011                ALLOC_GROW(buffer->orig, buffer->orig_nr + 1,
1012                                buffer->orig_alloc);
1013                buffer->orig[buffer->orig_nr].begin = buffer->text.ptr + i;
1014                buffer->orig[buffer->orig_nr].end = buffer->text.ptr + j;
1015                buffer->orig_nr++;
1016
1017                /* store one word */
1018                ALLOC_GROW(out->ptr, out->size + j - i + 1, alloc);
1019                memcpy(out->ptr + out->size, buffer->text.ptr + i, j - i);
1020                out->ptr[out->size + j - i] = '\n';
1021                out->size += j - i + 1;
1022
1023                i = j - 1;
1024        }
1025}
1026
1027/* this executes the word diff on the accumulated buffers */
1028static void diff_words_show(struct diff_words_data *diff_words)
1029{
1030        xpparam_t xpp;
1031        xdemitconf_t xecfg;
1032        mmfile_t minus, plus;
1033        struct diff_words_style *style = diff_words->style;
1034
1035        struct diff_options *opt = diff_words->opt;
1036        const char *line_prefix;
1037
1038        assert(opt);
1039        line_prefix = diff_line_prefix(opt);
1040
1041        /* special case: only removal */
1042        if (!diff_words->plus.text.size) {
1043                fputs(line_prefix, diff_words->opt->file);
1044                fn_out_diff_words_write_helper(diff_words->opt->file,
1045                        &style->old, style->newline,
1046                        diff_words->minus.text.size,
1047                        diff_words->minus.text.ptr, line_prefix);
1048                diff_words->minus.text.size = 0;
1049                return;
1050        }
1051
1052        diff_words->current_plus = diff_words->plus.text.ptr;
1053        diff_words->last_minus = 0;
1054
1055        memset(&xpp, 0, sizeof(xpp));
1056        memset(&xecfg, 0, sizeof(xecfg));
1057        diff_words_fill(&diff_words->minus, &minus, diff_words->word_regex);
1058        diff_words_fill(&diff_words->plus, &plus, diff_words->word_regex);
1059        xpp.flags = 0;
1060        /* as only the hunk header will be parsed, we need a 0-context */
1061        xecfg.ctxlen = 0;
1062        if (xdi_diff_outf(&minus, &plus, fn_out_diff_words_aux, diff_words,
1063                          &xpp, &xecfg))
1064                die("unable to generate word diff");
1065        free(minus.ptr);
1066        free(plus.ptr);
1067        if (diff_words->current_plus != diff_words->plus.text.ptr +
1068                        diff_words->plus.text.size) {
1069                if (color_words_output_graph_prefix(diff_words))
1070                        fputs(line_prefix, diff_words->opt->file);
1071                fn_out_diff_words_write_helper(diff_words->opt->file,
1072                        &style->ctx, style->newline,
1073                        diff_words->plus.text.ptr + diff_words->plus.text.size
1074                        - diff_words->current_plus, diff_words->current_plus,
1075                        line_prefix);
1076        }
1077        diff_words->minus.text.size = diff_words->plus.text.size = 0;
1078}
1079
1080/* In "color-words" mode, show word-diff of words accumulated in the buffer */
1081static void diff_words_flush(struct emit_callback *ecbdata)
1082{
1083        if (ecbdata->diff_words->minus.text.size ||
1084            ecbdata->diff_words->plus.text.size)
1085                diff_words_show(ecbdata->diff_words);
1086}
1087
1088static void diff_filespec_load_driver(struct diff_filespec *one)
1089{
1090        /* Use already-loaded driver */
1091        if (one->driver)
1092                return;
1093
1094        if (S_ISREG(one->mode))
1095                one->driver = userdiff_find_by_path(one->path);
1096
1097        /* Fallback to default settings */
1098        if (!one->driver)
1099                one->driver = userdiff_find_by_name("default");
1100}
1101
1102static const char *userdiff_word_regex(struct diff_filespec *one)
1103{
1104        diff_filespec_load_driver(one);
1105        return one->driver->word_regex;
1106}
1107
1108static void init_diff_words_data(struct emit_callback *ecbdata,
1109                                 struct diff_options *orig_opts,
1110                                 struct diff_filespec *one,
1111                                 struct diff_filespec *two)
1112{
1113        int i;
1114        struct diff_options *o = xmalloc(sizeof(struct diff_options));
1115        memcpy(o, orig_opts, sizeof(struct diff_options));
1116
1117        ecbdata->diff_words =
1118                xcalloc(1, sizeof(struct diff_words_data));
1119        ecbdata->diff_words->type = o->word_diff;
1120        ecbdata->diff_words->opt = o;
1121        if (!o->word_regex)
1122                o->word_regex = userdiff_word_regex(one);
1123        if (!o->word_regex)
1124                o->word_regex = userdiff_word_regex(two);
1125        if (!o->word_regex)
1126                o->word_regex = diff_word_regex_cfg;
1127        if (o->word_regex) {
1128                ecbdata->diff_words->word_regex = (regex_t *)
1129                        xmalloc(sizeof(regex_t));
1130                if (regcomp(ecbdata->diff_words->word_regex,
1131                            o->word_regex,
1132                            REG_EXTENDED | REG_NEWLINE))
1133                        die ("Invalid regular expression: %s",
1134                             o->word_regex);
1135        }
1136        for (i = 0; i < ARRAY_SIZE(diff_words_styles); i++) {
1137                if (o->word_diff == diff_words_styles[i].type) {
1138                        ecbdata->diff_words->style =
1139                                &diff_words_styles[i];
1140                        break;
1141                }
1142        }
1143        if (want_color(o->use_color)) {
1144                struct diff_words_style *st = ecbdata->diff_words->style;
1145                st->old.color = diff_get_color_opt(o, DIFF_FILE_OLD);
1146                st->new.color = diff_get_color_opt(o, DIFF_FILE_NEW);
1147                st->ctx.color = diff_get_color_opt(o, DIFF_CONTEXT);
1148        }
1149}
1150
1151static void free_diff_words_data(struct emit_callback *ecbdata)
1152{
1153        if (ecbdata->diff_words) {
1154                diff_words_flush(ecbdata);
1155                free (ecbdata->diff_words->opt);
1156                free (ecbdata->diff_words->minus.text.ptr);
1157                free (ecbdata->diff_words->minus.orig);
1158                free (ecbdata->diff_words->plus.text.ptr);
1159                free (ecbdata->diff_words->plus.orig);
1160                if (ecbdata->diff_words->word_regex) {
1161                        regfree(ecbdata->diff_words->word_regex);
1162                        free(ecbdata->diff_words->word_regex);
1163                }
1164                free(ecbdata->diff_words);
1165                ecbdata->diff_words = NULL;
1166        }
1167}
1168
1169const char *diff_get_color(int diff_use_color, enum color_diff ix)
1170{
1171        if (want_color(diff_use_color))
1172                return diff_colors[ix];
1173        return "";
1174}
1175
1176const char *diff_line_prefix(struct diff_options *opt)
1177{
1178        struct strbuf *msgbuf;
1179        if (!opt->output_prefix)
1180                return "";
1181
1182        msgbuf = opt->output_prefix(opt, opt->output_prefix_data);
1183        return msgbuf->buf;
1184}
1185
1186static unsigned long sane_truncate_line(struct emit_callback *ecb, char *line, unsigned long len)
1187{
1188        const char *cp;
1189        unsigned long allot;
1190        size_t l = len;
1191
1192        if (ecb->truncate)
1193                return ecb->truncate(line, len);
1194        cp = line;
1195        allot = l;
1196        while (0 < l) {
1197                (void) utf8_width(&cp, &l);
1198                if (!cp)
1199                        break; /* truncated in the middle? */
1200        }
1201        return allot - l;
1202}
1203
1204static void find_lno(const char *line, struct emit_callback *ecbdata)
1205{
1206        const char *p;
1207        ecbdata->lno_in_preimage = 0;
1208        ecbdata->lno_in_postimage = 0;
1209        p = strchr(line, '-');
1210        if (!p)
1211                return; /* cannot happen */
1212        ecbdata->lno_in_preimage = strtol(p + 1, NULL, 10);
1213        p = strchr(p, '+');
1214        if (!p)
1215                return; /* cannot happen */
1216        ecbdata->lno_in_postimage = strtol(p + 1, NULL, 10);
1217}
1218
1219static void fn_out_consume(void *priv, char *line, unsigned long len)
1220{
1221        struct emit_callback *ecbdata = priv;
1222        const char *meta = diff_get_color(ecbdata->color_diff, DIFF_METAINFO);
1223        const char *context = diff_get_color(ecbdata->color_diff, DIFF_CONTEXT);
1224        const char *reset = diff_get_color(ecbdata->color_diff, DIFF_RESET);
1225        struct diff_options *o = ecbdata->opt;
1226        const char *line_prefix = diff_line_prefix(o);
1227
1228        if (ecbdata->header) {
1229                fprintf(ecbdata->opt->file, "%s", ecbdata->header->buf);
1230                strbuf_reset(ecbdata->header);
1231                ecbdata->header = NULL;
1232        }
1233        *(ecbdata->found_changesp) = 1;
1234
1235        if (ecbdata->label_path[0]) {
1236                const char *name_a_tab, *name_b_tab;
1237
1238                name_a_tab = strchr(ecbdata->label_path[0], ' ') ? "\t" : "";
1239                name_b_tab = strchr(ecbdata->label_path[1], ' ') ? "\t" : "";
1240
1241                fprintf(ecbdata->opt->file, "%s%s--- %s%s%s\n",
1242                        line_prefix, meta, ecbdata->label_path[0], reset, name_a_tab);
1243                fprintf(ecbdata->opt->file, "%s%s+++ %s%s%s\n",
1244                        line_prefix, meta, ecbdata->label_path[1], reset, name_b_tab);
1245                ecbdata->label_path[0] = ecbdata->label_path[1] = NULL;
1246        }
1247
1248        if (diff_suppress_blank_empty
1249            && len == 2 && line[0] == ' ' && line[1] == '\n') {
1250                line[0] = '\n';
1251                len = 1;
1252        }
1253
1254        if (line[0] == '@') {
1255                if (ecbdata->diff_words)
1256                        diff_words_flush(ecbdata);
1257                len = sane_truncate_line(ecbdata, line, len);
1258                find_lno(line, ecbdata);
1259                emit_hunk_header(ecbdata, line, len);
1260                if (line[len-1] != '\n')
1261                        putc('\n', ecbdata->opt->file);
1262                return;
1263        }
1264
1265        if (len < 1) {
1266                emit_line(ecbdata->opt, reset, reset, line, len);
1267                if (ecbdata->diff_words
1268                    && ecbdata->diff_words->type == DIFF_WORDS_PORCELAIN)
1269                        fputs("~\n", ecbdata->opt->file);
1270                return;
1271        }
1272
1273        if (ecbdata->diff_words) {
1274                if (line[0] == '-') {
1275                        diff_words_append(line, len,
1276                                          &ecbdata->diff_words->minus);
1277                        return;
1278                } else if (line[0] == '+') {
1279                        diff_words_append(line, len,
1280                                          &ecbdata->diff_words->plus);
1281                        return;
1282                } else if (starts_with(line, "\\ ")) {
1283                        /*
1284                         * Eat the "no newline at eof" marker as if we
1285                         * saw a "+" or "-" line with nothing on it,
1286                         * and return without diff_words_flush() to
1287                         * defer processing. If this is the end of
1288                         * preimage, more "+" lines may come after it.
1289                         */
1290                        return;
1291                }
1292                diff_words_flush(ecbdata);
1293                if (ecbdata->diff_words->type == DIFF_WORDS_PORCELAIN) {
1294                        emit_line(ecbdata->opt, context, reset, line, len);
1295                        fputs("~\n", ecbdata->opt->file);
1296                } else {
1297                        /*
1298                         * Skip the prefix character, if any.  With
1299                         * diff_suppress_blank_empty, there may be
1300                         * none.
1301                         */
1302                        if (line[0] != '\n') {
1303                              line++;
1304                              len--;
1305                        }
1306                        emit_line(ecbdata->opt, context, reset, line, len);
1307                }
1308                return;
1309        }
1310
1311        switch (line[0]) {
1312        case '+':
1313                ecbdata->lno_in_postimage++;
1314                emit_add_line(reset, ecbdata, line + 1, len - 1);
1315                break;
1316        case '-':
1317                ecbdata->lno_in_preimage++;
1318                emit_del_line(reset, ecbdata, line + 1, len - 1);
1319                break;
1320        case ' ':
1321                ecbdata->lno_in_postimage++;
1322                ecbdata->lno_in_preimage++;
1323                emit_context_line(reset, ecbdata, line + 1, len - 1);
1324                break;
1325        default:
1326                /* incomplete line at the end */
1327                ecbdata->lno_in_preimage++;
1328                emit_line(ecbdata->opt,
1329                          diff_get_color(ecbdata->color_diff, DIFF_CONTEXT),
1330                          reset, line, len);
1331                break;
1332        }
1333}
1334
1335static char *pprint_rename(const char *a, const char *b)
1336{
1337        const char *old = a;
1338        const char *new = b;
1339        struct strbuf name = STRBUF_INIT;
1340        int pfx_length, sfx_length;
1341        int pfx_adjust_for_slash;
1342        int len_a = strlen(a);
1343        int len_b = strlen(b);
1344        int a_midlen, b_midlen;
1345        int qlen_a = quote_c_style(a, NULL, NULL, 0);
1346        int qlen_b = quote_c_style(b, NULL, NULL, 0);
1347
1348        if (qlen_a || qlen_b) {
1349                quote_c_style(a, &name, NULL, 0);
1350                strbuf_addstr(&name, " => ");
1351                quote_c_style(b, &name, NULL, 0);
1352                return strbuf_detach(&name, NULL);
1353        }
1354
1355        /* Find common prefix */
1356        pfx_length = 0;
1357        while (*old && *new && *old == *new) {
1358                if (*old == '/')
1359                        pfx_length = old - a + 1;
1360                old++;
1361                new++;
1362        }
1363
1364        /* Find common suffix */
1365        old = a + len_a;
1366        new = b + len_b;
1367        sfx_length = 0;
1368        /*
1369         * If there is a common prefix, it must end in a slash.  In
1370         * that case we let this loop run 1 into the prefix to see the
1371         * same slash.
1372         *
1373         * If there is no common prefix, we cannot do this as it would
1374         * underrun the input strings.
1375         */
1376        pfx_adjust_for_slash = (pfx_length ? 1 : 0);
1377        while (a + pfx_length - pfx_adjust_for_slash <= old &&
1378               b + pfx_length - pfx_adjust_for_slash <= new &&
1379               *old == *new) {
1380                if (*old == '/')
1381                        sfx_length = len_a - (old - a);
1382                old--;
1383                new--;
1384        }
1385
1386        /*
1387         * pfx{mid-a => mid-b}sfx
1388         * {pfx-a => pfx-b}sfx
1389         * pfx{sfx-a => sfx-b}
1390         * name-a => name-b
1391         */
1392        a_midlen = len_a - pfx_length - sfx_length;
1393        b_midlen = len_b - pfx_length - sfx_length;
1394        if (a_midlen < 0)
1395                a_midlen = 0;
1396        if (b_midlen < 0)
1397                b_midlen = 0;
1398
1399        strbuf_grow(&name, pfx_length + a_midlen + b_midlen + sfx_length + 7);
1400        if (pfx_length + sfx_length) {
1401                strbuf_add(&name, a, pfx_length);
1402                strbuf_addch(&name, '{');
1403        }
1404        strbuf_add(&name, a + pfx_length, a_midlen);
1405        strbuf_addstr(&name, " => ");
1406        strbuf_add(&name, b + pfx_length, b_midlen);
1407        if (pfx_length + sfx_length) {
1408                strbuf_addch(&name, '}');
1409                strbuf_add(&name, a + len_a - sfx_length, sfx_length);
1410        }
1411        return strbuf_detach(&name, NULL);
1412}
1413
1414struct diffstat_t {
1415        int nr;
1416        int alloc;
1417        struct diffstat_file {
1418                char *from_name;
1419                char *name;
1420                char *print_name;
1421                unsigned is_unmerged:1;
1422                unsigned is_binary:1;
1423                unsigned is_renamed:1;
1424                unsigned is_interesting:1;
1425                uintmax_t added, deleted;
1426        } **files;
1427};
1428
1429static struct diffstat_file *diffstat_add(struct diffstat_t *diffstat,
1430                                          const char *name_a,
1431                                          const char *name_b)
1432{
1433        struct diffstat_file *x;
1434        x = xcalloc(1, sizeof(*x));
1435        ALLOC_GROW(diffstat->files, diffstat->nr + 1, diffstat->alloc);
1436        diffstat->files[diffstat->nr++] = x;
1437        if (name_b) {
1438                x->from_name = xstrdup(name_a);
1439                x->name = xstrdup(name_b);
1440                x->is_renamed = 1;
1441        }
1442        else {
1443                x->from_name = NULL;
1444                x->name = xstrdup(name_a);
1445        }
1446        return x;
1447}
1448
1449static void diffstat_consume(void *priv, char *line, unsigned long len)
1450{
1451        struct diffstat_t *diffstat = priv;
1452        struct diffstat_file *x = diffstat->files[diffstat->nr - 1];
1453
1454        if (line[0] == '+')
1455                x->added++;
1456        else if (line[0] == '-')
1457                x->deleted++;
1458}
1459
1460const char mime_boundary_leader[] = "------------";
1461
1462static int scale_linear(int it, int width, int max_change)
1463{
1464        if (!it)
1465                return 0;
1466        /*
1467         * make sure that at least one '-' or '+' is printed if
1468         * there is any change to this path. The easiest way is to
1469         * scale linearly as if the alloted width is one column shorter
1470         * than it is, and then add 1 to the result.
1471         */
1472        return 1 + (it * (width - 1) / max_change);
1473}
1474
1475static void show_name(FILE *file,
1476                      const char *prefix, const char *name, int len)
1477{
1478        fprintf(file, " %s%-*s |", prefix, len, name);
1479}
1480
1481static void show_graph(FILE *file, char ch, int cnt, const char *set, const char *reset)
1482{
1483        if (cnt <= 0)
1484                return;
1485        fprintf(file, "%s", set);
1486        while (cnt--)
1487                putc(ch, file);
1488        fprintf(file, "%s", reset);
1489}
1490
1491static void fill_print_name(struct diffstat_file *file)
1492{
1493        char *pname;
1494
1495        if (file->print_name)
1496                return;
1497
1498        if (!file->is_renamed) {
1499                struct strbuf buf = STRBUF_INIT;
1500                if (quote_c_style(file->name, &buf, NULL, 0)) {
1501                        pname = strbuf_detach(&buf, NULL);
1502                } else {
1503                        pname = file->name;
1504                        strbuf_release(&buf);
1505                }
1506        } else {
1507                pname = pprint_rename(file->from_name, file->name);
1508        }
1509        file->print_name = pname;
1510}
1511
1512int print_stat_summary(FILE *fp, int files, int insertions, int deletions)
1513{
1514        struct strbuf sb = STRBUF_INIT;
1515        int ret;
1516
1517        if (!files) {
1518                assert(insertions == 0 && deletions == 0);
1519                return fprintf(fp, "%s\n", " 0 files changed");
1520        }
1521
1522        strbuf_addf(&sb,
1523                    (files == 1) ? " %d file changed" : " %d files changed",
1524                    files);
1525
1526        /*
1527         * For binary diff, the caller may want to print "x files
1528         * changed" with insertions == 0 && deletions == 0.
1529         *
1530         * Not omitting "0 insertions(+), 0 deletions(-)" in this case
1531         * is probably less confusing (i.e skip over "2 files changed
1532         * but nothing about added/removed lines? Is this a bug in Git?").
1533         */
1534        if (insertions || deletions == 0) {
1535                strbuf_addf(&sb,
1536                            (insertions == 1) ? ", %d insertion(+)" : ", %d insertions(+)",
1537                            insertions);
1538        }
1539
1540        if (deletions || insertions == 0) {
1541                strbuf_addf(&sb,
1542                            (deletions == 1) ? ", %d deletion(-)" : ", %d deletions(-)",
1543                            deletions);
1544        }
1545        strbuf_addch(&sb, '\n');
1546        ret = fputs(sb.buf, fp);
1547        strbuf_release(&sb);
1548        return ret;
1549}
1550
1551static void show_stats(struct diffstat_t *data, struct diff_options *options)
1552{
1553        int i, len, add, del, adds = 0, dels = 0;
1554        uintmax_t max_change = 0, max_len = 0;
1555        int total_files = data->nr, count;
1556        int width, name_width, graph_width, number_width = 0, bin_width = 0;
1557        const char *reset, *add_c, *del_c;
1558        const char *line_prefix = "";
1559        int extra_shown = 0;
1560
1561        if (data->nr == 0)
1562                return;
1563
1564        line_prefix = diff_line_prefix(options);
1565        count = options->stat_count ? options->stat_count : data->nr;
1566
1567        reset = diff_get_color_opt(options, DIFF_RESET);
1568        add_c = diff_get_color_opt(options, DIFF_FILE_NEW);
1569        del_c = diff_get_color_opt(options, DIFF_FILE_OLD);
1570
1571        /*
1572         * Find the longest filename and max number of changes
1573         */
1574        for (i = 0; (i < count) && (i < data->nr); i++) {
1575                struct diffstat_file *file = data->files[i];
1576                uintmax_t change = file->added + file->deleted;
1577
1578                if (!file->is_interesting && (change == 0)) {
1579                        count++; /* not shown == room for one more */
1580                        continue;
1581                }
1582                fill_print_name(file);
1583                len = strlen(file->print_name);
1584                if (max_len < len)
1585                        max_len = len;
1586
1587                if (file->is_unmerged) {
1588                        /* "Unmerged" is 8 characters */
1589                        bin_width = bin_width < 8 ? 8 : bin_width;
1590                        continue;
1591                }
1592                if (file->is_binary) {
1593                        /* "Bin XXX -> YYY bytes" */
1594                        int w = 14 + decimal_width(file->added)
1595                                + decimal_width(file->deleted);
1596                        bin_width = bin_width < w ? w : bin_width;
1597                        /* Display change counts aligned with "Bin" */
1598                        number_width = 3;
1599                        continue;
1600                }
1601
1602                if (max_change < change)
1603                        max_change = change;
1604        }
1605        count = i; /* where we can stop scanning in data->files[] */
1606
1607        /*
1608         * We have width = stat_width or term_columns() columns total.
1609         * We want a maximum of min(max_len, stat_name_width) for the name part.
1610         * We want a maximum of min(max_change, stat_graph_width) for the +- part.
1611         * We also need 1 for " " and 4 + decimal_width(max_change)
1612         * for " | NNNN " and one the empty column at the end, altogether
1613         * 6 + decimal_width(max_change).
1614         *
1615         * If there's not enough space, we will use the smaller of
1616         * stat_name_width (if set) and 5/8*width for the filename,
1617         * and the rest for constant elements + graph part, but no more
1618         * than stat_graph_width for the graph part.
1619         * (5/8 gives 50 for filename and 30 for the constant parts + graph
1620         * for the standard terminal size).
1621         *
1622         * In other words: stat_width limits the maximum width, and
1623         * stat_name_width fixes the maximum width of the filename,
1624         * and is also used to divide available columns if there
1625         * aren't enough.
1626         *
1627         * Binary files are displayed with "Bin XXX -> YYY bytes"
1628         * instead of the change count and graph. This part is treated
1629         * similarly to the graph part, except that it is not
1630         * "scaled". If total width is too small to accommodate the
1631         * guaranteed minimum width of the filename part and the
1632         * separators and this message, this message will "overflow"
1633         * making the line longer than the maximum width.
1634         */
1635
1636        if (options->stat_width == -1)
1637                width = term_columns() - options->output_prefix_length;
1638        else
1639                width = options->stat_width ? options->stat_width : 80;
1640        number_width = decimal_width(max_change) > number_width ?
1641                decimal_width(max_change) : number_width;
1642
1643        if (options->stat_graph_width == -1)
1644                options->stat_graph_width = diff_stat_graph_width;
1645
1646        /*
1647         * Guarantee 3/8*16==6 for the graph part
1648         * and 5/8*16==10 for the filename part
1649         */
1650        if (width < 16 + 6 + number_width)
1651                width = 16 + 6 + number_width;
1652
1653        /*
1654         * First assign sizes that are wanted, ignoring available width.
1655         * strlen("Bin XXX -> YYY bytes") == bin_width, and the part
1656         * starting from "XXX" should fit in graph_width.
1657         */
1658        graph_width = max_change + 4 > bin_width ? max_change : bin_width - 4;
1659        if (options->stat_graph_width &&
1660            options->stat_graph_width < graph_width)
1661                graph_width = options->stat_graph_width;
1662
1663        name_width = (options->stat_name_width > 0 &&
1664                      options->stat_name_width < max_len) ?
1665                options->stat_name_width : max_len;
1666
1667        /*
1668         * Adjust adjustable widths not to exceed maximum width
1669         */
1670        if (name_width + number_width + 6 + graph_width > width) {
1671                if (graph_width > width * 3/8 - number_width - 6) {
1672                        graph_width = width * 3/8 - number_width - 6;
1673                        if (graph_width < 6)
1674                                graph_width = 6;
1675                }
1676
1677                if (options->stat_graph_width &&
1678                    graph_width > options->stat_graph_width)
1679                        graph_width = options->stat_graph_width;
1680                if (name_width > width - number_width - 6 - graph_width)
1681                        name_width = width - number_width - 6 - graph_width;
1682                else
1683                        graph_width = width - number_width - 6 - name_width;
1684        }
1685
1686        /*
1687         * From here name_width is the width of the name area,
1688         * and graph_width is the width of the graph area.
1689         * max_change is used to scale graph properly.
1690         */
1691        for (i = 0; i < count; i++) {
1692                const char *prefix = "";
1693                struct diffstat_file *file = data->files[i];
1694                char *name = file->print_name;
1695                uintmax_t added = file->added;
1696                uintmax_t deleted = file->deleted;
1697                int name_len;
1698
1699                if (!file->is_interesting && (added + deleted == 0))
1700                        continue;
1701
1702                /*
1703                 * "scale" the filename
1704                 */
1705                len = name_width;
1706                name_len = strlen(name);
1707                if (name_width < name_len) {
1708                        char *slash;
1709                        prefix = "...";
1710                        len -= 3;
1711                        name += name_len - len;
1712                        slash = strchr(name, '/');
1713                        if (slash)
1714                                name = slash;
1715                }
1716
1717                if (file->is_binary) {
1718                        fprintf(options->file, "%s", line_prefix);
1719                        show_name(options->file, prefix, name, len);
1720                        fprintf(options->file, " %*s", number_width, "Bin");
1721                        if (!added && !deleted) {
1722                                putc('\n', options->file);
1723                                continue;
1724                        }
1725                        fprintf(options->file, " %s%"PRIuMAX"%s",
1726                                del_c, deleted, reset);
1727                        fprintf(options->file, " -> ");
1728                        fprintf(options->file, "%s%"PRIuMAX"%s",
1729                                add_c, added, reset);
1730                        fprintf(options->file, " bytes");
1731                        fprintf(options->file, "\n");
1732                        continue;
1733                }
1734                else if (file->is_unmerged) {
1735                        fprintf(options->file, "%s", line_prefix);
1736                        show_name(options->file, prefix, name, len);
1737                        fprintf(options->file, " Unmerged\n");
1738                        continue;
1739                }
1740
1741                /*
1742                 * scale the add/delete
1743                 */
1744                add = added;
1745                del = deleted;
1746
1747                if (graph_width <= max_change) {
1748                        int total = scale_linear(add + del, graph_width, max_change);
1749                        if (total < 2 && add && del)
1750                                /* width >= 2 due to the sanity check */
1751                                total = 2;
1752                        if (add < del) {
1753                                add = scale_linear(add, graph_width, max_change);
1754                                del = total - add;
1755                        } else {
1756                                del = scale_linear(del, graph_width, max_change);
1757                                add = total - del;
1758                        }
1759                }
1760                fprintf(options->file, "%s", line_prefix);
1761                show_name(options->file, prefix, name, len);
1762                fprintf(options->file, " %*"PRIuMAX"%s",
1763                        number_width, added + deleted,
1764                        added + deleted ? " " : "");
1765                show_graph(options->file, '+', add, add_c, reset);
1766                show_graph(options->file, '-', del, del_c, reset);
1767                fprintf(options->file, "\n");
1768        }
1769
1770        for (i = 0; i < data->nr; i++) {
1771                struct diffstat_file *file = data->files[i];
1772                uintmax_t added = file->added;
1773                uintmax_t deleted = file->deleted;
1774
1775                if (file->is_unmerged ||
1776                    (!file->is_interesting && (added + deleted == 0))) {
1777                        total_files--;
1778                        continue;
1779                }
1780
1781                if (!file->is_binary) {
1782                        adds += added;
1783                        dels += deleted;
1784                }
1785                if (i < count)
1786                        continue;
1787                if (!extra_shown)
1788                        fprintf(options->file, "%s ...\n", line_prefix);
1789                extra_shown = 1;
1790        }
1791        fprintf(options->file, "%s", line_prefix);
1792        print_stat_summary(options->file, total_files, adds, dels);
1793}
1794
1795static void show_shortstats(struct diffstat_t *data, struct diff_options *options)
1796{
1797        int i, adds = 0, dels = 0, total_files = data->nr;
1798
1799        if (data->nr == 0)
1800                return;
1801
1802        for (i = 0; i < data->nr; i++) {
1803                int added = data->files[i]->added;
1804                int deleted= data->files[i]->deleted;
1805
1806                if (data->files[i]->is_unmerged ||
1807                    (!data->files[i]->is_interesting && (added + deleted == 0))) {
1808                        total_files--;
1809                } else if (!data->files[i]->is_binary) { /* don't count bytes */
1810                        adds += added;
1811                        dels += deleted;
1812                }
1813        }
1814        fprintf(options->file, "%s", diff_line_prefix(options));
1815        print_stat_summary(options->file, total_files, adds, dels);
1816}
1817
1818static void show_numstat(struct diffstat_t *data, struct diff_options *options)
1819{
1820        int i;
1821
1822        if (data->nr == 0)
1823                return;
1824
1825        for (i = 0; i < data->nr; i++) {
1826                struct diffstat_file *file = data->files[i];
1827
1828                fprintf(options->file, "%s", diff_line_prefix(options));
1829
1830                if (file->is_binary)
1831                        fprintf(options->file, "-\t-\t");
1832                else
1833                        fprintf(options->file,
1834                                "%"PRIuMAX"\t%"PRIuMAX"\t",
1835                                file->added, file->deleted);
1836                if (options->line_termination) {
1837                        fill_print_name(file);
1838                        if (!file->is_renamed)
1839                                write_name_quoted(file->name, options->file,
1840                                                  options->line_termination);
1841                        else {
1842                                fputs(file->print_name, options->file);
1843                                putc(options->line_termination, options->file);
1844                        }
1845                } else {
1846                        if (file->is_renamed) {
1847                                putc('\0', options->file);
1848                                write_name_quoted(file->from_name, options->file, '\0');
1849                        }
1850                        write_name_quoted(file->name, options->file, '\0');
1851                }
1852        }
1853}
1854
1855struct dirstat_file {
1856        const char *name;
1857        unsigned long changed;
1858};
1859
1860struct dirstat_dir {
1861        struct dirstat_file *files;
1862        int alloc, nr, permille, cumulative;
1863};
1864
1865static long gather_dirstat(struct diff_options *opt, struct dirstat_dir *dir,
1866                unsigned long changed, const char *base, int baselen)
1867{
1868        unsigned long this_dir = 0;
1869        unsigned int sources = 0;
1870        const char *line_prefix = diff_line_prefix(opt);
1871
1872        while (dir->nr) {
1873                struct dirstat_file *f = dir->files;
1874                int namelen = strlen(f->name);
1875                unsigned long this;
1876                char *slash;
1877
1878                if (namelen < baselen)
1879                        break;
1880                if (memcmp(f->name, base, baselen))
1881                        break;
1882                slash = strchr(f->name + baselen, '/');
1883                if (slash) {
1884                        int newbaselen = slash + 1 - f->name;
1885                        this = gather_dirstat(opt, dir, changed, f->name, newbaselen);
1886                        sources++;
1887                } else {
1888                        this = f->changed;
1889                        dir->files++;
1890                        dir->nr--;
1891                        sources += 2;
1892                }
1893                this_dir += this;
1894        }
1895
1896        /*
1897         * We don't report dirstat's for
1898         *  - the top level
1899         *  - or cases where everything came from a single directory
1900         *    under this directory (sources == 1).
1901         */
1902        if (baselen && sources != 1) {
1903                if (this_dir) {
1904                        int permille = this_dir * 1000 / changed;
1905                        if (permille >= dir->permille) {
1906                                fprintf(opt->file, "%s%4d.%01d%% %.*s\n", line_prefix,
1907                                        permille / 10, permille % 10, baselen, base);
1908                                if (!dir->cumulative)
1909                                        return 0;
1910                        }
1911                }
1912        }
1913        return this_dir;
1914}
1915
1916static int dirstat_compare(const void *_a, const void *_b)
1917{
1918        const struct dirstat_file *a = _a;
1919        const struct dirstat_file *b = _b;
1920        return strcmp(a->name, b->name);
1921}
1922
1923static void show_dirstat(struct diff_options *options)
1924{
1925        int i;
1926        unsigned long changed;
1927        struct dirstat_dir dir;
1928        struct diff_queue_struct *q = &diff_queued_diff;
1929
1930        dir.files = NULL;
1931        dir.alloc = 0;
1932        dir.nr = 0;
1933        dir.permille = options->dirstat_permille;
1934        dir.cumulative = DIFF_OPT_TST(options, DIRSTAT_CUMULATIVE);
1935
1936        changed = 0;
1937        for (i = 0; i < q->nr; i++) {
1938                struct diff_filepair *p = q->queue[i];
1939                const char *name;
1940                unsigned long copied, added, damage;
1941                int content_changed;
1942
1943                name = p->two->path ? p->two->path : p->one->path;
1944
1945                if (p->one->sha1_valid && p->two->sha1_valid)
1946                        content_changed = hashcmp(p->one->sha1, p->two->sha1);
1947                else
1948                        content_changed = 1;
1949
1950                if (!content_changed) {
1951                        /*
1952                         * The SHA1 has not changed, so pre-/post-content is
1953                         * identical. We can therefore skip looking at the
1954                         * file contents altogether.
1955                         */
1956                        damage = 0;
1957                        goto found_damage;
1958                }
1959
1960                if (DIFF_OPT_TST(options, DIRSTAT_BY_FILE)) {
1961                        /*
1962                         * In --dirstat-by-file mode, we don't really need to
1963                         * look at the actual file contents at all.
1964                         * The fact that the SHA1 changed is enough for us to
1965                         * add this file to the list of results
1966                         * (with each file contributing equal damage).
1967                         */
1968                        damage = 1;
1969                        goto found_damage;
1970                }
1971
1972                if (DIFF_FILE_VALID(p->one) && DIFF_FILE_VALID(p->two)) {
1973                        diff_populate_filespec(p->one, 0);
1974                        diff_populate_filespec(p->two, 0);
1975                        diffcore_count_changes(p->one, p->two, NULL, NULL, 0,
1976                                               &copied, &added);
1977                        diff_free_filespec_data(p->one);
1978                        diff_free_filespec_data(p->two);
1979                } else if (DIFF_FILE_VALID(p->one)) {
1980                        diff_populate_filespec(p->one, CHECK_SIZE_ONLY);
1981                        copied = added = 0;
1982                        diff_free_filespec_data(p->one);
1983                } else if (DIFF_FILE_VALID(p->two)) {
1984                        diff_populate_filespec(p->two, CHECK_SIZE_ONLY);
1985                        copied = 0;
1986                        added = p->two->size;
1987                        diff_free_filespec_data(p->two);
1988                } else
1989                        continue;
1990
1991                /*
1992                 * Original minus copied is the removed material,
1993                 * added is the new material.  They are both damages
1994                 * made to the preimage.
1995                 * If the resulting damage is zero, we know that
1996                 * diffcore_count_changes() considers the two entries to
1997                 * be identical, but since content_changed is true, we
1998                 * know that there must have been _some_ kind of change,
1999                 * so we force all entries to have damage > 0.
2000                 */
2001                damage = (p->one->size - copied) + added;
2002                if (!damage)
2003                        damage = 1;
2004
2005found_damage:
2006                ALLOC_GROW(dir.files, dir.nr + 1, dir.alloc);
2007                dir.files[dir.nr].name = name;
2008                dir.files[dir.nr].changed = damage;
2009                changed += damage;
2010                dir.nr++;
2011        }
2012
2013        /* This can happen even with many files, if everything was renames */
2014        if (!changed)
2015                return;
2016
2017        /* Show all directories with more than x% of the changes */
2018        qsort(dir.files, dir.nr, sizeof(dir.files[0]), dirstat_compare);
2019        gather_dirstat(options, &dir, changed, "", 0);
2020}
2021
2022static void show_dirstat_by_line(struct diffstat_t *data, struct diff_options *options)
2023{
2024        int i;
2025        unsigned long changed;
2026        struct dirstat_dir dir;
2027
2028        if (data->nr == 0)
2029                return;
2030
2031        dir.files = NULL;
2032        dir.alloc = 0;
2033        dir.nr = 0;
2034        dir.permille = options->dirstat_permille;
2035        dir.cumulative = DIFF_OPT_TST(options, DIRSTAT_CUMULATIVE);
2036
2037        changed = 0;
2038        for (i = 0; i < data->nr; i++) {
2039                struct diffstat_file *file = data->files[i];
2040                unsigned long damage = file->added + file->deleted;
2041                if (file->is_binary)
2042                        /*
2043                         * binary files counts bytes, not lines. Must find some
2044                         * way to normalize binary bytes vs. textual lines.
2045                         * The following heuristic assumes that there are 64
2046                         * bytes per "line".
2047                         * This is stupid and ugly, but very cheap...
2048                         */
2049                        damage = (damage + 63) / 64;
2050                ALLOC_GROW(dir.files, dir.nr + 1, dir.alloc);
2051                dir.files[dir.nr].name = file->name;
2052                dir.files[dir.nr].changed = damage;
2053                changed += damage;
2054                dir.nr++;
2055        }
2056
2057        /* This can happen even with many files, if everything was renames */
2058        if (!changed)
2059                return;
2060
2061        /* Show all directories with more than x% of the changes */
2062        qsort(dir.files, dir.nr, sizeof(dir.files[0]), dirstat_compare);
2063        gather_dirstat(options, &dir, changed, "", 0);
2064}
2065
2066static void free_diffstat_info(struct diffstat_t *diffstat)
2067{
2068        int i;
2069        for (i = 0; i < diffstat->nr; i++) {
2070                struct diffstat_file *f = diffstat->files[i];
2071                if (f->name != f->print_name)
2072                        free(f->print_name);
2073                free(f->name);
2074                free(f->from_name);
2075                free(f);
2076        }
2077        free(diffstat->files);
2078}
2079
2080struct checkdiff_t {
2081        const char *filename;
2082        int lineno;
2083        int conflict_marker_size;
2084        struct diff_options *o;
2085        unsigned ws_rule;
2086        unsigned status;
2087};
2088
2089static int is_conflict_marker(const char *line, int marker_size, unsigned long len)
2090{
2091        char firstchar;
2092        int cnt;
2093
2094        if (len < marker_size + 1)
2095                return 0;
2096        firstchar = line[0];
2097        switch (firstchar) {
2098        case '=': case '>': case '<': case '|':
2099                break;
2100        default:
2101                return 0;
2102        }
2103        for (cnt = 1; cnt < marker_size; cnt++)
2104                if (line[cnt] != firstchar)
2105                        return 0;
2106        /* line[1] thru line[marker_size-1] are same as firstchar */
2107        if (len < marker_size + 1 || !isspace(line[marker_size]))
2108                return 0;
2109        return 1;
2110}
2111
2112static void checkdiff_consume(void *priv, char *line, unsigned long len)
2113{
2114        struct checkdiff_t *data = priv;
2115        int marker_size = data->conflict_marker_size;
2116        const char *ws = diff_get_color(data->o->use_color, DIFF_WHITESPACE);
2117        const char *reset = diff_get_color(data->o->use_color, DIFF_RESET);
2118        const char *set = diff_get_color(data->o->use_color, DIFF_FILE_NEW);
2119        char *err;
2120        const char *line_prefix;
2121
2122        assert(data->o);
2123        line_prefix = diff_line_prefix(data->o);
2124
2125        if (line[0] == '+') {
2126                unsigned bad;
2127                data->lineno++;
2128                if (is_conflict_marker(line + 1, marker_size, len - 1)) {
2129                        data->status |= 1;
2130                        fprintf(data->o->file,
2131                                "%s%s:%d: leftover conflict marker\n",
2132                                line_prefix, data->filename, data->lineno);
2133                }
2134                bad = ws_check(line + 1, len - 1, data->ws_rule);
2135                if (!bad)
2136                        return;
2137                data->status |= bad;
2138                err = whitespace_error_string(bad);
2139                fprintf(data->o->file, "%s%s:%d: %s.\n",
2140                        line_prefix, data->filename, data->lineno, err);
2141                free(err);
2142                emit_line(data->o, set, reset, line, 1);
2143                ws_check_emit(line + 1, len - 1, data->ws_rule,
2144                              data->o->file, set, reset, ws);
2145        } else if (line[0] == ' ') {
2146                data->lineno++;
2147        } else if (line[0] == '@') {
2148                char *plus = strchr(line, '+');
2149                if (plus)
2150                        data->lineno = strtol(plus, NULL, 10) - 1;
2151                else
2152                        die("invalid diff");
2153        }
2154}
2155
2156static unsigned char *deflate_it(char *data,
2157                                 unsigned long size,
2158                                 unsigned long *result_size)
2159{
2160        int bound;
2161        unsigned char *deflated;
2162        git_zstream stream;
2163
2164        git_deflate_init(&stream, zlib_compression_level);
2165        bound = git_deflate_bound(&stream, size);
2166        deflated = xmalloc(bound);
2167        stream.next_out = deflated;
2168        stream.avail_out = bound;
2169
2170        stream.next_in = (unsigned char *)data;
2171        stream.avail_in = size;
2172        while (git_deflate(&stream, Z_FINISH) == Z_OK)
2173                ; /* nothing */
2174        git_deflate_end(&stream);
2175        *result_size = stream.total_out;
2176        return deflated;
2177}
2178
2179static void emit_binary_diff_body(FILE *file, mmfile_t *one, mmfile_t *two,
2180                                  const char *prefix)
2181{
2182        void *cp;
2183        void *delta;
2184        void *deflated;
2185        void *data;
2186        unsigned long orig_size;
2187        unsigned long delta_size;
2188        unsigned long deflate_size;
2189        unsigned long data_size;
2190
2191        /* We could do deflated delta, or we could do just deflated two,
2192         * whichever is smaller.
2193         */
2194        delta = NULL;
2195        deflated = deflate_it(two->ptr, two->size, &deflate_size);
2196        if (one->size && two->size) {
2197                delta = diff_delta(one->ptr, one->size,
2198                                   two->ptr, two->size,
2199                                   &delta_size, deflate_size);
2200                if (delta) {
2201                        void *to_free = delta;
2202                        orig_size = delta_size;
2203                        delta = deflate_it(delta, delta_size, &delta_size);
2204                        free(to_free);
2205                }
2206        }
2207
2208        if (delta && delta_size < deflate_size) {
2209                fprintf(file, "%sdelta %lu\n", prefix, orig_size);
2210                free(deflated);
2211                data = delta;
2212                data_size = delta_size;
2213        }
2214        else {
2215                fprintf(file, "%sliteral %lu\n", prefix, two->size);
2216                free(delta);
2217                data = deflated;
2218                data_size = deflate_size;
2219        }
2220
2221        /* emit data encoded in base85 */
2222        cp = data;
2223        while (data_size) {
2224                int bytes = (52 < data_size) ? 52 : data_size;
2225                char line[70];
2226                data_size -= bytes;
2227                if (bytes <= 26)
2228                        line[0] = bytes + 'A' - 1;
2229                else
2230                        line[0] = bytes - 26 + 'a' - 1;
2231                encode_85(line + 1, cp, bytes);
2232                cp = (char *) cp + bytes;
2233                fprintf(file, "%s", prefix);
2234                fputs(line, file);
2235                fputc('\n', file);
2236        }
2237        fprintf(file, "%s\n", prefix);
2238        free(data);
2239}
2240
2241static void emit_binary_diff(FILE *file, mmfile_t *one, mmfile_t *two,
2242                             const char *prefix)
2243{
2244        fprintf(file, "%sGIT binary patch\n", prefix);
2245        emit_binary_diff_body(file, one, two, prefix);
2246        emit_binary_diff_body(file, two, one, prefix);
2247}
2248
2249int diff_filespec_is_binary(struct diff_filespec *one)
2250{
2251        if (one->is_binary == -1) {
2252                diff_filespec_load_driver(one);
2253                if (one->driver->binary != -1)
2254                        one->is_binary = one->driver->binary;
2255                else {
2256                        if (!one->data && DIFF_FILE_VALID(one))
2257                                diff_populate_filespec(one, CHECK_BINARY);
2258                        if (one->is_binary == -1 && one->data)
2259                                one->is_binary = buffer_is_binary(one->data,
2260                                                one->size);
2261                        if (one->is_binary == -1)
2262                                one->is_binary = 0;
2263                }
2264        }
2265        return one->is_binary;
2266}
2267
2268static const struct userdiff_funcname *diff_funcname_pattern(struct diff_filespec *one)
2269{
2270        diff_filespec_load_driver(one);
2271        return one->driver->funcname.pattern ? &one->driver->funcname : NULL;
2272}
2273
2274void diff_set_mnemonic_prefix(struct diff_options *options, const char *a, const char *b)
2275{
2276        if (!options->a_prefix)
2277                options->a_prefix = a;
2278        if (!options->b_prefix)
2279                options->b_prefix = b;
2280}
2281
2282struct userdiff_driver *get_textconv(struct diff_filespec *one)
2283{
2284        if (!DIFF_FILE_VALID(one))
2285                return NULL;
2286
2287        diff_filespec_load_driver(one);
2288        return userdiff_get_textconv(one->driver);
2289}
2290
2291static void builtin_diff(const char *name_a,
2292                         const char *name_b,
2293                         struct diff_filespec *one,
2294                         struct diff_filespec *two,
2295                         const char *xfrm_msg,
2296                         int must_show_header,
2297                         struct diff_options *o,
2298                         int complete_rewrite)
2299{
2300        mmfile_t mf1, mf2;
2301        const char *lbl[2];
2302        char *a_one, *b_two;
2303        const char *meta = diff_get_color_opt(o, DIFF_METAINFO);
2304        const char *reset = diff_get_color_opt(o, DIFF_RESET);
2305        const char *a_prefix, *b_prefix;
2306        struct userdiff_driver *textconv_one = NULL;
2307        struct userdiff_driver *textconv_two = NULL;
2308        struct strbuf header = STRBUF_INIT;
2309        const char *line_prefix = diff_line_prefix(o);
2310
2311        if (DIFF_OPT_TST(o, SUBMODULE_LOG) &&
2312                        (!one->mode || S_ISGITLINK(one->mode)) &&
2313                        (!two->mode || S_ISGITLINK(two->mode))) {
2314                const char *del = diff_get_color_opt(o, DIFF_FILE_OLD);
2315                const char *add = diff_get_color_opt(o, DIFF_FILE_NEW);
2316                show_submodule_summary(o->file, one->path ? one->path : two->path,
2317                                line_prefix,
2318                                one->sha1, two->sha1, two->dirty_submodule,
2319                                meta, del, add, reset);
2320                return;
2321        }
2322
2323        if (DIFF_OPT_TST(o, ALLOW_TEXTCONV)) {
2324                textconv_one = get_textconv(one);
2325                textconv_two = get_textconv(two);
2326        }
2327
2328        diff_set_mnemonic_prefix(o, "a/", "b/");
2329        if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
2330                a_prefix = o->b_prefix;
2331                b_prefix = o->a_prefix;
2332        } else {
2333                a_prefix = o->a_prefix;
2334                b_prefix = o->b_prefix;
2335        }
2336
2337        /* Never use a non-valid filename anywhere if at all possible */
2338        name_a = DIFF_FILE_VALID(one) ? name_a : name_b;
2339        name_b = DIFF_FILE_VALID(two) ? name_b : name_a;
2340
2341        a_one = quote_two(a_prefix, name_a + (*name_a == '/'));
2342        b_two = quote_two(b_prefix, name_b + (*name_b == '/'));
2343        lbl[0] = DIFF_FILE_VALID(one) ? a_one : "/dev/null";
2344        lbl[1] = DIFF_FILE_VALID(two) ? b_two : "/dev/null";
2345        strbuf_addf(&header, "%s%sdiff --git %s %s%s\n", line_prefix, meta, a_one, b_two, reset);
2346        if (lbl[0][0] == '/') {
2347                /* /dev/null */
2348                strbuf_addf(&header, "%s%snew file mode %06o%s\n", line_prefix, meta, two->mode, reset);
2349                if (xfrm_msg)
2350                        strbuf_addstr(&header, xfrm_msg);
2351                must_show_header = 1;
2352        }
2353        else if (lbl[1][0] == '/') {
2354                strbuf_addf(&header, "%s%sdeleted file mode %06o%s\n", line_prefix, meta, one->mode, reset);
2355                if (xfrm_msg)
2356                        strbuf_addstr(&header, xfrm_msg);
2357                must_show_header = 1;
2358        }
2359        else {
2360                if (one->mode != two->mode) {
2361                        strbuf_addf(&header, "%s%sold mode %06o%s\n", line_prefix, meta, one->mode, reset);
2362                        strbuf_addf(&header, "%s%snew mode %06o%s\n", line_prefix, meta, two->mode, reset);
2363                        must_show_header = 1;
2364                }
2365                if (xfrm_msg)
2366                        strbuf_addstr(&header, xfrm_msg);
2367
2368                /*
2369                 * we do not run diff between different kind
2370                 * of objects.
2371                 */
2372                if ((one->mode ^ two->mode) & S_IFMT)
2373                        goto free_ab_and_return;
2374                if (complete_rewrite &&
2375                    (textconv_one || !diff_filespec_is_binary(one)) &&
2376                    (textconv_two || !diff_filespec_is_binary(two))) {
2377                        fprintf(o->file, "%s", header.buf);
2378                        strbuf_reset(&header);
2379                        emit_rewrite_diff(name_a, name_b, one, two,
2380                                                textconv_one, textconv_two, o);
2381                        o->found_changes = 1;
2382                        goto free_ab_and_return;
2383                }
2384        }
2385
2386        if (o->irreversible_delete && lbl[1][0] == '/') {
2387                fprintf(o->file, "%s", header.buf);
2388                strbuf_reset(&header);
2389                goto free_ab_and_return;
2390        } else if (!DIFF_OPT_TST(o, TEXT) &&
2391            ( (!textconv_one && diff_filespec_is_binary(one)) ||
2392              (!textconv_two && diff_filespec_is_binary(two)) )) {
2393                if (!one->data && !two->data &&
2394                    S_ISREG(one->mode) && S_ISREG(two->mode) &&
2395                    !DIFF_OPT_TST(o, BINARY)) {
2396                        if (!hashcmp(one->sha1, two->sha1)) {
2397                                if (must_show_header)
2398                                        fprintf(o->file, "%s", header.buf);
2399                                goto free_ab_and_return;
2400                        }
2401                        fprintf(o->file, "%s", header.buf);
2402                        fprintf(o->file, "%sBinary files %s and %s differ\n",
2403                                line_prefix, lbl[0], lbl[1]);
2404                        goto free_ab_and_return;
2405                }
2406                if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
2407                        die("unable to read files to diff");
2408                /* Quite common confusing case */
2409                if (mf1.size == mf2.size &&
2410                    !memcmp(mf1.ptr, mf2.ptr, mf1.size)) {
2411                        if (must_show_header)
2412                                fprintf(o->file, "%s", header.buf);
2413                        goto free_ab_and_return;
2414                }
2415                fprintf(o->file, "%s", header.buf);
2416                strbuf_reset(&header);
2417                if (DIFF_OPT_TST(o, BINARY))
2418                        emit_binary_diff(o->file, &mf1, &mf2, line_prefix);
2419                else
2420                        fprintf(o->file, "%sBinary files %s and %s differ\n",
2421                                line_prefix, lbl[0], lbl[1]);
2422                o->found_changes = 1;
2423        } else {
2424                /* Crazy xdl interfaces.. */
2425                const char *diffopts = getenv("GIT_DIFF_OPTS");
2426                const char *v;
2427                xpparam_t xpp;
2428                xdemitconf_t xecfg;
2429                struct emit_callback ecbdata;
2430                const struct userdiff_funcname *pe;
2431
2432                if (must_show_header) {
2433                        fprintf(o->file, "%s", header.buf);
2434                        strbuf_reset(&header);
2435                }
2436
2437                mf1.size = fill_textconv(textconv_one, one, &mf1.ptr);
2438                mf2.size = fill_textconv(textconv_two, two, &mf2.ptr);
2439
2440                pe = diff_funcname_pattern(one);
2441                if (!pe)
2442                        pe = diff_funcname_pattern(two);
2443
2444                memset(&xpp, 0, sizeof(xpp));
2445                memset(&xecfg, 0, sizeof(xecfg));
2446                memset(&ecbdata, 0, sizeof(ecbdata));
2447                ecbdata.label_path = lbl;
2448                ecbdata.color_diff = want_color(o->use_color);
2449                ecbdata.found_changesp = &o->found_changes;
2450                ecbdata.ws_rule = whitespace_rule(name_b);
2451                if (ecbdata.ws_rule & WS_BLANK_AT_EOF)
2452                        check_blank_at_eof(&mf1, &mf2, &ecbdata);
2453                ecbdata.opt = o;
2454                ecbdata.header = header.len ? &header : NULL;
2455                xpp.flags = o->xdl_opts;
2456                xecfg.ctxlen = o->context;
2457                xecfg.interhunkctxlen = o->interhunkcontext;
2458                xecfg.flags = XDL_EMIT_FUNCNAMES;
2459                if (DIFF_OPT_TST(o, FUNCCONTEXT))
2460                        xecfg.flags |= XDL_EMIT_FUNCCONTEXT;
2461                if (pe)
2462                        xdiff_set_find_func(&xecfg, pe->pattern, pe->cflags);
2463                if (!diffopts)
2464                        ;
2465                else if (skip_prefix(diffopts, "--unified=", &v))
2466                        xecfg.ctxlen = strtoul(v, NULL, 10);
2467                else if (skip_prefix(diffopts, "-u", &v))
2468                        xecfg.ctxlen = strtoul(v, NULL, 10);
2469                if (o->word_diff)
2470                        init_diff_words_data(&ecbdata, o, one, two);
2471                if (xdi_diff_outf(&mf1, &mf2, fn_out_consume, &ecbdata,
2472                                  &xpp, &xecfg))
2473                        die("unable to generate diff for %s", one->path);
2474                if (o->word_diff)
2475                        free_diff_words_data(&ecbdata);
2476                if (textconv_one)
2477                        free(mf1.ptr);
2478                if (textconv_two)
2479                        free(mf2.ptr);
2480                xdiff_clear_find_func(&xecfg);
2481        }
2482
2483 free_ab_and_return:
2484        strbuf_release(&header);
2485        diff_free_filespec_data(one);
2486        diff_free_filespec_data(two);
2487        free(a_one);
2488        free(b_two);
2489        return;
2490}
2491
2492static void builtin_diffstat(const char *name_a, const char *name_b,
2493                             struct diff_filespec *one,
2494                             struct diff_filespec *two,
2495                             struct diffstat_t *diffstat,
2496                             struct diff_options *o,
2497                             struct diff_filepair *p)
2498{
2499        mmfile_t mf1, mf2;
2500        struct diffstat_file *data;
2501        int same_contents;
2502        int complete_rewrite = 0;
2503
2504        if (!DIFF_PAIR_UNMERGED(p)) {
2505                if (p->status == DIFF_STATUS_MODIFIED && p->score)
2506                        complete_rewrite = 1;
2507        }
2508
2509        data = diffstat_add(diffstat, name_a, name_b);
2510        data->is_interesting = p->status != DIFF_STATUS_UNKNOWN;
2511
2512        if (!one || !two) {
2513                data->is_unmerged = 1;
2514                return;
2515        }
2516
2517        same_contents = !hashcmp(one->sha1, two->sha1);
2518
2519        if (diff_filespec_is_binary(one) || diff_filespec_is_binary(two)) {
2520                data->is_binary = 1;
2521                if (same_contents) {
2522                        data->added = 0;
2523                        data->deleted = 0;
2524                } else {
2525                        data->added = diff_filespec_size(two);
2526                        data->deleted = diff_filespec_size(one);
2527                }
2528        }
2529
2530        else if (complete_rewrite) {
2531                diff_populate_filespec(one, 0);
2532                diff_populate_filespec(two, 0);
2533                data->deleted = count_lines(one->data, one->size);
2534                data->added = count_lines(two->data, two->size);
2535        }
2536
2537        else if (!same_contents) {
2538                /* Crazy xdl interfaces.. */
2539                xpparam_t xpp;
2540                xdemitconf_t xecfg;
2541
2542                if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
2543                        die("unable to read files to diff");
2544
2545                memset(&xpp, 0, sizeof(xpp));
2546                memset(&xecfg, 0, sizeof(xecfg));
2547                xpp.flags = o->xdl_opts;
2548                xecfg.ctxlen = o->context;
2549                xecfg.interhunkctxlen = o->interhunkcontext;
2550                if (xdi_diff_outf(&mf1, &mf2, diffstat_consume, diffstat,
2551                                  &xpp, &xecfg))
2552                        die("unable to generate diffstat for %s", one->path);
2553        }
2554
2555        diff_free_filespec_data(one);
2556        diff_free_filespec_data(two);
2557}
2558
2559static void builtin_checkdiff(const char *name_a, const char *name_b,
2560                              const char *attr_path,
2561                              struct diff_filespec *one,
2562                              struct diff_filespec *two,
2563                              struct diff_options *o)
2564{
2565        mmfile_t mf1, mf2;
2566        struct checkdiff_t data;
2567
2568        if (!two)
2569                return;
2570
2571        memset(&data, 0, sizeof(data));
2572        data.filename = name_b ? name_b : name_a;
2573        data.lineno = 0;
2574        data.o = o;
2575        data.ws_rule = whitespace_rule(attr_path);
2576        data.conflict_marker_size = ll_merge_marker_size(attr_path);
2577
2578        if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
2579                die("unable to read files to diff");
2580
2581        /*
2582         * All the other codepaths check both sides, but not checking
2583         * the "old" side here is deliberate.  We are checking the newly
2584         * introduced changes, and as long as the "new" side is text, we
2585         * can and should check what it introduces.
2586         */
2587        if (diff_filespec_is_binary(two))
2588                goto free_and_return;
2589        else {
2590                /* Crazy xdl interfaces.. */
2591                xpparam_t xpp;
2592                xdemitconf_t xecfg;
2593
2594                memset(&xpp, 0, sizeof(xpp));
2595                memset(&xecfg, 0, sizeof(xecfg));
2596                xecfg.ctxlen = 1; /* at least one context line */
2597                xpp.flags = 0;
2598                if (xdi_diff_outf(&mf1, &mf2, checkdiff_consume, &data,
2599                                  &xpp, &xecfg))
2600                        die("unable to generate checkdiff for %s", one->path);
2601
2602                if (data.ws_rule & WS_BLANK_AT_EOF) {
2603                        struct emit_callback ecbdata;
2604                        int blank_at_eof;
2605
2606                        ecbdata.ws_rule = data.ws_rule;
2607                        check_blank_at_eof(&mf1, &mf2, &ecbdata);
2608                        blank_at_eof = ecbdata.blank_at_eof_in_postimage;
2609
2610                        if (blank_at_eof) {
2611                                static char *err;
2612                                if (!err)
2613                                        err = whitespace_error_string(WS_BLANK_AT_EOF);
2614                                fprintf(o->file, "%s:%d: %s.\n",
2615                                        data.filename, blank_at_eof, err);
2616                                data.status = 1; /* report errors */
2617                        }
2618                }
2619        }
2620 free_and_return:
2621        diff_free_filespec_data(one);
2622        diff_free_filespec_data(two);
2623        if (data.status)
2624                DIFF_OPT_SET(o, CHECK_FAILED);
2625}
2626
2627struct diff_filespec *alloc_filespec(const char *path)
2628{
2629        struct diff_filespec *spec;
2630
2631        FLEXPTR_ALLOC_STR(spec, path, path);
2632        spec->count = 1;
2633        spec->is_binary = -1;
2634        return spec;
2635}
2636
2637void free_filespec(struct diff_filespec *spec)
2638{
2639        if (!--spec->count) {
2640                diff_free_filespec_data(spec);
2641                free(spec);
2642        }
2643}
2644
2645void fill_filespec(struct diff_filespec *spec, const unsigned char *sha1,
2646                   int sha1_valid, unsigned short mode)
2647{
2648        if (mode) {
2649                spec->mode = canon_mode(mode);
2650                hashcpy(spec->sha1, sha1);
2651                spec->sha1_valid = sha1_valid;
2652        }
2653}
2654
2655/*
2656 * Given a name and sha1 pair, if the index tells us the file in
2657 * the work tree has that object contents, return true, so that
2658 * prepare_temp_file() does not have to inflate and extract.
2659 */
2660static int reuse_worktree_file(const char *name, const unsigned char *sha1, int want_file)
2661{
2662        const struct cache_entry *ce;
2663        struct stat st;
2664        int pos, len;
2665
2666        /*
2667         * We do not read the cache ourselves here, because the
2668         * benchmark with my previous version that always reads cache
2669         * shows that it makes things worse for diff-tree comparing
2670         * two linux-2.6 kernel trees in an already checked out work
2671         * tree.  This is because most diff-tree comparisons deal with
2672         * only a small number of files, while reading the cache is
2673         * expensive for a large project, and its cost outweighs the
2674         * savings we get by not inflating the object to a temporary
2675         * file.  Practically, this code only helps when we are used
2676         * by diff-cache --cached, which does read the cache before
2677         * calling us.
2678         */
2679        if (!active_cache)
2680                return 0;
2681
2682        /* We want to avoid the working directory if our caller
2683         * doesn't need the data in a normal file, this system
2684         * is rather slow with its stat/open/mmap/close syscalls,
2685         * and the object is contained in a pack file.  The pack
2686         * is probably already open and will be faster to obtain
2687         * the data through than the working directory.  Loose
2688         * objects however would tend to be slower as they need
2689         * to be individually opened and inflated.
2690         */
2691        if (!FAST_WORKING_DIRECTORY && !want_file && has_sha1_pack(sha1))
2692                return 0;
2693
2694        len = strlen(name);
2695        pos = cache_name_pos(name, len);
2696        if (pos < 0)
2697                return 0;
2698        ce = active_cache[pos];
2699
2700        /*
2701         * This is not the sha1 we are looking for, or
2702         * unreusable because it is not a regular file.
2703         */
2704        if (hashcmp(sha1, ce->sha1) || !S_ISREG(ce->ce_mode))
2705                return 0;
2706
2707        /*
2708         * If ce is marked as "assume unchanged", there is no
2709         * guarantee that work tree matches what we are looking for.
2710         */
2711        if ((ce->ce_flags & CE_VALID) || ce_skip_worktree(ce))
2712                return 0;
2713
2714        /*
2715         * If ce matches the file in the work tree, we can reuse it.
2716         */
2717        if (ce_uptodate(ce) ||
2718            (!lstat(name, &st) && !ce_match_stat(ce, &st, 0)))
2719                return 1;
2720
2721        return 0;
2722}
2723
2724static int diff_populate_gitlink(struct diff_filespec *s, int size_only)
2725{
2726        struct strbuf buf = STRBUF_INIT;
2727        char *dirty = "";
2728
2729        /* Are we looking at the work tree? */
2730        if (s->dirty_submodule)
2731                dirty = "-dirty";
2732
2733        strbuf_addf(&buf, "Subproject commit %s%s\n", sha1_to_hex(s->sha1), dirty);
2734        s->size = buf.len;
2735        if (size_only) {
2736                s->data = NULL;
2737                strbuf_release(&buf);
2738        } else {
2739                s->data = strbuf_detach(&buf, NULL);
2740                s->should_free = 1;
2741        }
2742        return 0;
2743}
2744
2745/*
2746 * While doing rename detection and pickaxe operation, we may need to
2747 * grab the data for the blob (or file) for our own in-core comparison.
2748 * diff_filespec has data and size fields for this purpose.
2749 */
2750int diff_populate_filespec(struct diff_filespec *s, unsigned int flags)
2751{
2752        int size_only = flags & CHECK_SIZE_ONLY;
2753        int err = 0;
2754        /*
2755         * demote FAIL to WARN to allow inspecting the situation
2756         * instead of refusing.
2757         */
2758        enum safe_crlf crlf_warn = (safe_crlf == SAFE_CRLF_FAIL
2759                                    ? SAFE_CRLF_WARN
2760                                    : safe_crlf);
2761
2762        if (!DIFF_FILE_VALID(s))
2763                die("internal error: asking to populate invalid file.");
2764        if (S_ISDIR(s->mode))
2765                return -1;
2766
2767        if (s->data)
2768                return 0;
2769
2770        if (size_only && 0 < s->size)
2771                return 0;
2772
2773        if (S_ISGITLINK(s->mode))
2774                return diff_populate_gitlink(s, size_only);
2775
2776        if (!s->sha1_valid ||
2777            reuse_worktree_file(s->path, s->sha1, 0)) {
2778                struct strbuf buf = STRBUF_INIT;
2779                struct stat st;
2780                int fd;
2781
2782                if (lstat(s->path, &st) < 0) {
2783                        if (errno == ENOENT) {
2784                        err_empty:
2785                                err = -1;
2786                        empty:
2787                                s->data = (char *)"";
2788                                s->size = 0;
2789                                return err;
2790                        }
2791                }
2792                s->size = xsize_t(st.st_size);
2793                if (!s->size)
2794                        goto empty;
2795                if (S_ISLNK(st.st_mode)) {
2796                        struct strbuf sb = STRBUF_INIT;
2797
2798                        if (strbuf_readlink(&sb, s->path, s->size))
2799                                goto err_empty;
2800                        s->size = sb.len;
2801                        s->data = strbuf_detach(&sb, NULL);
2802                        s->should_free = 1;
2803                        return 0;
2804                }
2805                if (size_only)
2806                        return 0;
2807                if ((flags & CHECK_BINARY) &&
2808                    s->size > big_file_threshold && s->is_binary == -1) {
2809                        s->is_binary = 1;
2810                        return 0;
2811                }
2812                fd = open(s->path, O_RDONLY);
2813                if (fd < 0)
2814                        goto err_empty;
2815                s->data = xmmap(NULL, s->size, PROT_READ, MAP_PRIVATE, fd, 0);
2816                close(fd);
2817                s->should_munmap = 1;
2818
2819                /*
2820                 * Convert from working tree format to canonical git format
2821                 */
2822                if (convert_to_git(s->path, s->data, s->size, &buf, crlf_warn)) {
2823                        size_t size = 0;
2824                        munmap(s->data, s->size);
2825                        s->should_munmap = 0;
2826                        s->data = strbuf_detach(&buf, &size);
2827                        s->size = size;
2828                        s->should_free = 1;
2829                }
2830        }
2831        else {
2832                enum object_type type;
2833                if (size_only || (flags & CHECK_BINARY)) {
2834                        type = sha1_object_info(s->sha1, &s->size);
2835                        if (type < 0)
2836                                die("unable to read %s", sha1_to_hex(s->sha1));
2837                        if (size_only)
2838                                return 0;
2839                        if (s->size > big_file_threshold && s->is_binary == -1) {
2840                                s->is_binary = 1;
2841                                return 0;
2842                        }
2843                }
2844                s->data = read_sha1_file(s->sha1, &type, &s->size);
2845                if (!s->data)
2846                        die("unable to read %s", sha1_to_hex(s->sha1));
2847                s->should_free = 1;
2848        }
2849        return 0;
2850}
2851
2852void diff_free_filespec_blob(struct diff_filespec *s)
2853{
2854        if (s->should_free)
2855                free(s->data);
2856        else if (s->should_munmap)
2857                munmap(s->data, s->size);
2858
2859        if (s->should_free || s->should_munmap) {
2860                s->should_free = s->should_munmap = 0;
2861                s->data = NULL;
2862        }
2863}
2864
2865void diff_free_filespec_data(struct diff_filespec *s)
2866{
2867        diff_free_filespec_blob(s);
2868        free(s->cnt_data);
2869        s->cnt_data = NULL;
2870}
2871
2872static void prep_temp_blob(const char *path, struct diff_tempfile *temp,
2873                           void *blob,
2874                           unsigned long size,
2875                           const unsigned char *sha1,
2876                           int mode)
2877{
2878        int fd;
2879        struct strbuf buf = STRBUF_INIT;
2880        struct strbuf template = STRBUF_INIT;
2881        char *path_dup = xstrdup(path);
2882        const char *base = basename(path_dup);
2883
2884        /* Generate "XXXXXX_basename.ext" */
2885        strbuf_addstr(&template, "XXXXXX_");
2886        strbuf_addstr(&template, base);
2887
2888        fd = mks_tempfile_ts(&temp->tempfile, template.buf, strlen(base) + 1);
2889        if (fd < 0)
2890                die_errno("unable to create temp-file");
2891        if (convert_to_working_tree(path,
2892                        (const char *)blob, (size_t)size, &buf)) {
2893                blob = buf.buf;
2894                size = buf.len;
2895        }
2896        if (write_in_full(fd, blob, size) != size)
2897                die_errno("unable to write temp-file");
2898        close_tempfile(&temp->tempfile);
2899        temp->name = get_tempfile_path(&temp->tempfile);
2900        sha1_to_hex_r(temp->hex, sha1);
2901        xsnprintf(temp->mode, sizeof(temp->mode), "%06o", mode);
2902        strbuf_release(&buf);
2903        strbuf_release(&template);
2904        free(path_dup);
2905}
2906
2907static struct diff_tempfile *prepare_temp_file(const char *name,
2908                struct diff_filespec *one)
2909{
2910        struct diff_tempfile *temp = claim_diff_tempfile();
2911
2912        if (!DIFF_FILE_VALID(one)) {
2913        not_a_valid_file:
2914                /* A '-' entry produces this for file-2, and
2915                 * a '+' entry produces this for file-1.
2916                 */
2917                temp->name = "/dev/null";
2918                xsnprintf(temp->hex, sizeof(temp->hex), ".");
2919                xsnprintf(temp->mode, sizeof(temp->mode), ".");
2920                return temp;
2921        }
2922
2923        if (!S_ISGITLINK(one->mode) &&
2924            (!one->sha1_valid ||
2925             reuse_worktree_file(name, one->sha1, 1))) {
2926                struct stat st;
2927                if (lstat(name, &st) < 0) {
2928                        if (errno == ENOENT)
2929                                goto not_a_valid_file;
2930                        die_errno("stat(%s)", name);
2931                }
2932                if (S_ISLNK(st.st_mode)) {
2933                        struct strbuf sb = STRBUF_INIT;
2934                        if (strbuf_readlink(&sb, name, st.st_size) < 0)
2935                                die_errno("readlink(%s)", name);
2936                        prep_temp_blob(name, temp, sb.buf, sb.len,
2937                                       (one->sha1_valid ?
2938                                        one->sha1 : null_sha1),
2939                                       (one->sha1_valid ?
2940                                        one->mode : S_IFLNK));
2941                        strbuf_release(&sb);
2942                }
2943                else {
2944                        /* we can borrow from the file in the work tree */
2945                        temp->name = name;
2946                        if (!one->sha1_valid)
2947                                sha1_to_hex_r(temp->hex, null_sha1);
2948                        else
2949                                sha1_to_hex_r(temp->hex, one->sha1);
2950                        /* Even though we may sometimes borrow the
2951                         * contents from the work tree, we always want
2952                         * one->mode.  mode is trustworthy even when
2953                         * !(one->sha1_valid), as long as
2954                         * DIFF_FILE_VALID(one).
2955                         */
2956                        xsnprintf(temp->mode, sizeof(temp->mode), "%06o", one->mode);
2957                }
2958                return temp;
2959        }
2960        else {
2961                if (diff_populate_filespec(one, 0))
2962                        die("cannot read data blob for %s", one->path);
2963                prep_temp_blob(name, temp, one->data, one->size,
2964                               one->sha1, one->mode);
2965        }
2966        return temp;
2967}
2968
2969static void add_external_diff_name(struct argv_array *argv,
2970                                   const char *name,
2971                                   struct diff_filespec *df)
2972{
2973        struct diff_tempfile *temp = prepare_temp_file(name, df);
2974        argv_array_push(argv, temp->name);
2975        argv_array_push(argv, temp->hex);
2976        argv_array_push(argv, temp->mode);
2977}
2978
2979/* An external diff command takes:
2980 *
2981 * diff-cmd name infile1 infile1-sha1 infile1-mode \
2982 *               infile2 infile2-sha1 infile2-mode [ rename-to ]
2983 *
2984 */
2985static void run_external_diff(const char *pgm,
2986                              const char *name,
2987                              const char *other,
2988                              struct diff_filespec *one,
2989                              struct diff_filespec *two,
2990                              const char *xfrm_msg,
2991                              int complete_rewrite,
2992                              struct diff_options *o)
2993{
2994        struct argv_array argv = ARGV_ARRAY_INIT;
2995        struct argv_array env = ARGV_ARRAY_INIT;
2996        struct diff_queue_struct *q = &diff_queued_diff;
2997
2998        argv_array_push(&argv, pgm);
2999        argv_array_push(&argv, name);
3000
3001        if (one && two) {
3002                add_external_diff_name(&argv, name, one);
3003                if (!other)
3004                        add_external_diff_name(&argv, name, two);
3005                else {
3006                        add_external_diff_name(&argv, other, two);
3007                        argv_array_push(&argv, other);
3008                        argv_array_push(&argv, xfrm_msg);
3009                }
3010        }
3011
3012        argv_array_pushf(&env, "GIT_DIFF_PATH_COUNTER=%d", ++o->diff_path_counter);
3013        argv_array_pushf(&env, "GIT_DIFF_PATH_TOTAL=%d", q->nr);
3014
3015        if (run_command_v_opt_cd_env(argv.argv, RUN_USING_SHELL, NULL, env.argv))
3016                die(_("external diff died, stopping at %s"), name);
3017
3018        remove_tempfile();
3019        argv_array_clear(&argv);
3020        argv_array_clear(&env);
3021}
3022
3023static int similarity_index(struct diff_filepair *p)
3024{
3025        return p->score * 100 / MAX_SCORE;
3026}
3027
3028static void fill_metainfo(struct strbuf *msg,
3029                          const char *name,
3030                          const char *other,
3031                          struct diff_filespec *one,
3032                          struct diff_filespec *two,
3033                          struct diff_options *o,
3034                          struct diff_filepair *p,
3035                          int *must_show_header,
3036                          int use_color)
3037{
3038        const char *set = diff_get_color(use_color, DIFF_METAINFO);
3039        const char *reset = diff_get_color(use_color, DIFF_RESET);
3040        const char *line_prefix = diff_line_prefix(o);
3041
3042        *must_show_header = 1;
3043        strbuf_init(msg, PATH_MAX * 2 + 300);
3044        switch (p->status) {
3045        case DIFF_STATUS_COPIED:
3046                strbuf_addf(msg, "%s%ssimilarity index %d%%",
3047                            line_prefix, set, similarity_index(p));
3048                strbuf_addf(msg, "%s\n%s%scopy from ",
3049                            reset,  line_prefix, set);
3050                quote_c_style(name, msg, NULL, 0);
3051                strbuf_addf(msg, "%s\n%s%scopy to ", reset, line_prefix, set);
3052                quote_c_style(other, msg, NULL, 0);
3053                strbuf_addf(msg, "%s\n", reset);
3054                break;
3055        case DIFF_STATUS_RENAMED:
3056                strbuf_addf(msg, "%s%ssimilarity index %d%%",
3057                            line_prefix, set, similarity_index(p));
3058                strbuf_addf(msg, "%s\n%s%srename from ",
3059                            reset, line_prefix, set);
3060                quote_c_style(name, msg, NULL, 0);
3061                strbuf_addf(msg, "%s\n%s%srename to ",
3062                            reset, line_prefix, set);
3063                quote_c_style(other, msg, NULL, 0);
3064                strbuf_addf(msg, "%s\n", reset);
3065                break;
3066        case DIFF_STATUS_MODIFIED:
3067                if (p->score) {
3068                        strbuf_addf(msg, "%s%sdissimilarity index %d%%%s\n",
3069                                    line_prefix,
3070                                    set, similarity_index(p), reset);
3071                        break;
3072                }
3073                /* fallthru */
3074        default:
3075                *must_show_header = 0;
3076        }
3077        if (one && two && hashcmp(one->sha1, two->sha1)) {
3078                int abbrev = DIFF_OPT_TST(o, FULL_INDEX) ? 40 : DEFAULT_ABBREV;
3079
3080                if (DIFF_OPT_TST(o, BINARY)) {
3081                        mmfile_t mf;
3082                        if ((!fill_mmfile(&mf, one) && diff_filespec_is_binary(one)) ||
3083                            (!fill_mmfile(&mf, two) && diff_filespec_is_binary(two)))
3084                                abbrev = 40;
3085                }
3086                strbuf_addf(msg, "%s%sindex %s..", line_prefix, set,
3087                            find_unique_abbrev(one->sha1, abbrev));
3088                strbuf_addstr(msg, find_unique_abbrev(two->sha1, abbrev));
3089                if (one->mode == two->mode)
3090                        strbuf_addf(msg, " %06o", one->mode);
3091                strbuf_addf(msg, "%s\n", reset);
3092        }
3093}
3094
3095static void run_diff_cmd(const char *pgm,
3096                         const char *name,
3097                         const char *other,
3098                         const char *attr_path,
3099                         struct diff_filespec *one,
3100                         struct diff_filespec *two,
3101                         struct strbuf *msg,
3102                         struct diff_options *o,
3103                         struct diff_filepair *p)
3104{
3105        const char *xfrm_msg = NULL;
3106        int complete_rewrite = (p->status == DIFF_STATUS_MODIFIED) && p->score;
3107        int must_show_header = 0;
3108
3109
3110        if (DIFF_OPT_TST(o, ALLOW_EXTERNAL)) {
3111                struct userdiff_driver *drv = userdiff_find_by_path(attr_path);
3112                if (drv && drv->external)
3113                        pgm = drv->external;
3114        }
3115
3116        if (msg) {
3117                /*
3118                 * don't use colors when the header is intended for an
3119                 * external diff driver
3120                 */
3121                fill_metainfo(msg, name, other, one, two, o, p,
3122                              &must_show_header,
3123                              want_color(o->use_color) && !pgm);
3124                xfrm_msg = msg->len ? msg->buf : NULL;
3125        }
3126
3127        if (pgm) {
3128                run_external_diff(pgm, name, other, one, two, xfrm_msg,
3129                                  complete_rewrite, o);
3130                return;
3131        }
3132        if (one && two)
3133                builtin_diff(name, other ? other : name,
3134                             one, two, xfrm_msg, must_show_header,
3135                             o, complete_rewrite);
3136        else
3137                fprintf(o->file, "* Unmerged path %s\n", name);
3138}
3139
3140static void diff_fill_sha1_info(struct diff_filespec *one)
3141{
3142        if (DIFF_FILE_VALID(one)) {
3143                if (!one->sha1_valid) {
3144                        struct stat st;
3145                        if (one->is_stdin) {
3146                                hashcpy(one->sha1, null_sha1);
3147                                return;
3148                        }
3149                        if (lstat(one->path, &st) < 0)
3150                                die_errno("stat '%s'", one->path);
3151                        if (index_path(one->sha1, one->path, &st, 0))
3152                                die("cannot hash %s", one->path);
3153                }
3154        }
3155        else
3156                hashclr(one->sha1);
3157}
3158
3159static void strip_prefix(int prefix_length, const char **namep, const char **otherp)
3160{
3161        /* Strip the prefix but do not molest /dev/null and absolute paths */
3162        if (*namep && **namep != '/') {
3163                *namep += prefix_length;
3164                if (**namep == '/')
3165                        ++*namep;
3166        }
3167        if (*otherp && **otherp != '/') {
3168                *otherp += prefix_length;
3169                if (**otherp == '/')
3170                        ++*otherp;
3171        }
3172}
3173
3174static void run_diff(struct diff_filepair *p, struct diff_options *o)
3175{
3176        const char *pgm = external_diff();
3177        struct strbuf msg;
3178        struct diff_filespec *one = p->one;
3179        struct diff_filespec *two = p->two;
3180        const char *name;
3181        const char *other;
3182        const char *attr_path;
3183
3184        name  = p->one->path;
3185        other = (strcmp(name, p->two->path) ? p->two->path : NULL);
3186        attr_path = name;
3187        if (o->prefix_length)
3188                strip_prefix(o->prefix_length, &name, &other);
3189
3190        if (!DIFF_OPT_TST(o, ALLOW_EXTERNAL))
3191                pgm = NULL;
3192
3193        if (DIFF_PAIR_UNMERGED(p)) {
3194                run_diff_cmd(pgm, name, NULL, attr_path,
3195                             NULL, NULL, NULL, o, p);
3196                return;
3197        }
3198
3199        diff_fill_sha1_info(one);
3200        diff_fill_sha1_info(two);
3201
3202        if (!pgm &&
3203            DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) &&
3204            (S_IFMT & one->mode) != (S_IFMT & two->mode)) {
3205                /*
3206                 * a filepair that changes between file and symlink
3207                 * needs to be split into deletion and creation.
3208                 */
3209                struct diff_filespec *null = alloc_filespec(two->path);
3210                run_diff_cmd(NULL, name, other, attr_path,
3211                             one, null, &msg, o, p);
3212                free(null);
3213                strbuf_release(&msg);
3214
3215                null = alloc_filespec(one->path);
3216                run_diff_cmd(NULL, name, other, attr_path,
3217                             null, two, &msg, o, p);
3218                free(null);
3219        }
3220        else
3221                run_diff_cmd(pgm, name, other, attr_path,
3222                             one, two, &msg, o, p);
3223
3224        strbuf_release(&msg);
3225}
3226
3227static void run_diffstat(struct diff_filepair *p, struct diff_options *o,
3228                         struct diffstat_t *diffstat)
3229{
3230        const char *name;
3231        const char *other;
3232
3233        if (DIFF_PAIR_UNMERGED(p)) {
3234                /* unmerged */
3235                builtin_diffstat(p->one->path, NULL, NULL, NULL, diffstat, o, p);
3236                return;
3237        }
3238
3239        name = p->one->path;
3240        other = (strcmp(name, p->two->path) ? p->two->path : NULL);
3241
3242        if (o->prefix_length)
3243                strip_prefix(o->prefix_length, &name, &other);
3244
3245        diff_fill_sha1_info(p->one);
3246        diff_fill_sha1_info(p->two);
3247
3248        builtin_diffstat(name, other, p->one, p->two, diffstat, o, p);
3249}
3250
3251static void run_checkdiff(struct diff_filepair *p, struct diff_options *o)
3252{
3253        const char *name;
3254        const char *other;
3255        const char *attr_path;
3256
3257        if (DIFF_PAIR_UNMERGED(p)) {
3258                /* unmerged */
3259                return;
3260        }
3261
3262        name = p->one->path;
3263        other = (strcmp(name, p->two->path) ? p->two->path : NULL);
3264        attr_path = other ? other : name;
3265
3266        if (o->prefix_length)
3267                strip_prefix(o->prefix_length, &name, &other);
3268
3269        diff_fill_sha1_info(p->one);
3270        diff_fill_sha1_info(p->two);
3271
3272        builtin_checkdiff(name, other, attr_path, p->one, p->two, o);
3273}
3274
3275void diff_setup(struct diff_options *options)
3276{
3277        memcpy(options, &default_diff_options, sizeof(*options));
3278
3279        options->file = stdout;
3280
3281        options->line_termination = '\n';
3282        options->break_opt = -1;
3283        options->rename_limit = -1;
3284        options->dirstat_permille = diff_dirstat_permille_default;
3285        options->context = diff_context_default;
3286        options->ws_error_highlight = WSEH_NEW;
3287        DIFF_OPT_SET(options, RENAME_EMPTY);
3288
3289        /* pathchange left =NULL by default */
3290        options->change = diff_change;
3291        options->add_remove = diff_addremove;
3292        options->use_color = diff_use_color_default;
3293        options->detect_rename = diff_detect_rename_default;
3294        options->xdl_opts |= diff_algorithm;
3295        if (diff_indent_heuristic)
3296                DIFF_XDL_SET(options, INDENT_HEURISTIC);
3297        else if (diff_compaction_heuristic)
3298                DIFF_XDL_SET(options, COMPACTION_HEURISTIC);
3299
3300        options->orderfile = diff_order_file_cfg;
3301
3302        if (diff_no_prefix) {
3303                options->a_prefix = options->b_prefix = "";
3304        } else if (!diff_mnemonic_prefix) {
3305                options->a_prefix = "a/";
3306                options->b_prefix = "b/";
3307        }
3308}
3309
3310void diff_setup_done(struct diff_options *options)
3311{
3312        int count = 0;
3313
3314        if (options->set_default)
3315                options->set_default(options);
3316
3317        if (options->output_format & DIFF_FORMAT_NAME)
3318                count++;
3319        if (options->output_format & DIFF_FORMAT_NAME_STATUS)
3320                count++;
3321        if (options->output_format & DIFF_FORMAT_CHECKDIFF)
3322                count++;
3323        if (options->output_format & DIFF_FORMAT_NO_OUTPUT)
3324                count++;
3325        if (count > 1)
3326                die("--name-only, --name-status, --check and -s are mutually exclusive");
3327
3328        /*
3329         * Most of the time we can say "there are changes"
3330         * only by checking if there are changed paths, but
3331         * --ignore-whitespace* options force us to look
3332         * inside contents.
3333         */
3334
3335        if (DIFF_XDL_TST(options, IGNORE_WHITESPACE) ||
3336            DIFF_XDL_TST(options, IGNORE_WHITESPACE_CHANGE) ||
3337            DIFF_XDL_TST(options, IGNORE_WHITESPACE_AT_EOL))
3338                DIFF_OPT_SET(options, DIFF_FROM_CONTENTS);
3339        else
3340                DIFF_OPT_CLR(options, DIFF_FROM_CONTENTS);
3341
3342        if (DIFF_OPT_TST(options, FIND_COPIES_HARDER))
3343                options->detect_rename = DIFF_DETECT_COPY;
3344
3345        if (!DIFF_OPT_TST(options, RELATIVE_NAME))
3346                options->prefix = NULL;
3347        if (options->prefix)
3348                options->prefix_length = strlen(options->prefix);
3349        else
3350                options->prefix_length = 0;
3351
3352        if (options->output_format & (DIFF_FORMAT_NAME |
3353                                      DIFF_FORMAT_NAME_STATUS |
3354                                      DIFF_FORMAT_CHECKDIFF |
3355                                      DIFF_FORMAT_NO_OUTPUT))
3356                options->output_format &= ~(DIFF_FORMAT_RAW |
3357                                            DIFF_FORMAT_NUMSTAT |
3358                                            DIFF_FORMAT_DIFFSTAT |
3359                                            DIFF_FORMAT_SHORTSTAT |
3360                                            DIFF_FORMAT_DIRSTAT |
3361                                            DIFF_FORMAT_SUMMARY |
3362                                            DIFF_FORMAT_PATCH);
3363
3364        /*
3365         * These cases always need recursive; we do not drop caller-supplied
3366         * recursive bits for other formats here.
3367         */
3368        if (options->output_format & (DIFF_FORMAT_PATCH |
3369                                      DIFF_FORMAT_NUMSTAT |
3370                                      DIFF_FORMAT_DIFFSTAT |
3371                                      DIFF_FORMAT_SHORTSTAT |
3372                                      DIFF_FORMAT_DIRSTAT |
3373                                      DIFF_FORMAT_SUMMARY |
3374                                      DIFF_FORMAT_CHECKDIFF))
3375                DIFF_OPT_SET(options, RECURSIVE);
3376        /*
3377         * Also pickaxe would not work very well if you do not say recursive
3378         */
3379        if (options->pickaxe)
3380                DIFF_OPT_SET(options, RECURSIVE);
3381        /*
3382         * When patches are generated, submodules diffed against the work tree
3383         * must be checked for dirtiness too so it can be shown in the output
3384         */
3385        if (options->output_format & DIFF_FORMAT_PATCH)
3386                DIFF_OPT_SET(options, DIRTY_SUBMODULES);
3387
3388        if (options->detect_rename && options->rename_limit < 0)
3389                options->rename_limit = diff_rename_limit_default;
3390        if (options->setup & DIFF_SETUP_USE_CACHE) {
3391                if (!active_cache)
3392                        /* read-cache does not die even when it fails
3393                         * so it is safe for us to do this here.  Also
3394                         * it does not smudge active_cache or active_nr
3395                         * when it fails, so we do not have to worry about
3396                         * cleaning it up ourselves either.
3397                         */
3398                        read_cache();
3399        }
3400        if (options->abbrev <= 0 || 40 < options->abbrev)
3401                options->abbrev = 40; /* full */
3402
3403        /*
3404         * It does not make sense to show the first hit we happened
3405         * to have found.  It does not make sense not to return with
3406         * exit code in such a case either.
3407         */
3408        if (DIFF_OPT_TST(options, QUICK)) {
3409                options->output_format = DIFF_FORMAT_NO_OUTPUT;
3410                DIFF_OPT_SET(options, EXIT_WITH_STATUS);
3411        }
3412
3413        options->diff_path_counter = 0;
3414
3415        if (DIFF_OPT_TST(options, FOLLOW_RENAMES) && options->pathspec.nr != 1)
3416                die(_("--follow requires exactly one pathspec"));
3417}
3418
3419static int opt_arg(const char *arg, int arg_short, const char *arg_long, int *val)
3420{
3421        char c, *eq;
3422        int len;
3423
3424        if (*arg != '-')
3425                return 0;
3426        c = *++arg;
3427        if (!c)
3428                return 0;
3429        if (c == arg_short) {
3430                c = *++arg;
3431                if (!c)
3432                        return 1;
3433                if (val && isdigit(c)) {
3434                        char *end;
3435                        int n = strtoul(arg, &end, 10);
3436                        if (*end)
3437                                return 0;
3438                        *val = n;
3439                        return 1;
3440                }
3441                return 0;
3442        }
3443        if (c != '-')
3444                return 0;
3445        arg++;
3446        eq = strchrnul(arg, '=');
3447        len = eq - arg;
3448        if (!len || strncmp(arg, arg_long, len))
3449                return 0;
3450        if (*eq) {
3451                int n;
3452                char *end;
3453                if (!isdigit(*++eq))
3454                        return 0;
3455                n = strtoul(eq, &end, 10);
3456                if (*end)
3457                        return 0;
3458                *val = n;
3459        }
3460        return 1;
3461}
3462
3463static int diff_scoreopt_parse(const char *opt);
3464
3465static inline int short_opt(char opt, const char **argv,
3466                            const char **optarg)
3467{
3468        const char *arg = argv[0];
3469        if (arg[0] != '-' || arg[1] != opt)
3470                return 0;
3471        if (arg[2] != '\0') {
3472                *optarg = arg + 2;
3473                return 1;
3474        }
3475        if (!argv[1])
3476                die("Option '%c' requires a value", opt);
3477        *optarg = argv[1];
3478        return 2;
3479}
3480
3481int parse_long_opt(const char *opt, const char **argv,
3482                   const char **optarg)
3483{
3484        const char *arg = argv[0];
3485        if (!skip_prefix(arg, "--", &arg))
3486                return 0;
3487        if (!skip_prefix(arg, opt, &arg))
3488                return 0;
3489        if (*arg == '=') { /* stuck form: --option=value */
3490                *optarg = arg + 1;
3491                return 1;
3492        }
3493        if (*arg != '\0')
3494                return 0;
3495        /* separate form: --option value */
3496        if (!argv[1])
3497                die("Option '--%s' requires a value", opt);
3498        *optarg = argv[1];
3499        return 2;
3500}
3501
3502static int stat_opt(struct diff_options *options, const char **av)
3503{
3504        const char *arg = av[0];
3505        char *end;
3506        int width = options->stat_width;
3507        int name_width = options->stat_name_width;
3508        int graph_width = options->stat_graph_width;
3509        int count = options->stat_count;
3510        int argcount = 1;
3511
3512        if (!skip_prefix(arg, "--stat", &arg))
3513                die("BUG: stat option does not begin with --stat: %s", arg);
3514        end = (char *)arg;
3515
3516        switch (*arg) {
3517        case '-':
3518                if (skip_prefix(arg, "-width", &arg)) {
3519                        if (*arg == '=')
3520                                width = strtoul(arg + 1, &end, 10);
3521                        else if (!*arg && !av[1])
3522                                die("Option '--stat-width' requires a value");
3523                        else if (!*arg) {
3524                                width = strtoul(av[1], &end, 10);
3525                                argcount = 2;
3526                        }
3527                } else if (skip_prefix(arg, "-name-width", &arg)) {
3528                        if (*arg == '=')
3529                                name_width = strtoul(arg + 1, &end, 10);
3530                        else if (!*arg && !av[1])
3531                                die("Option '--stat-name-width' requires a value");
3532                        else if (!*arg) {
3533                                name_width = strtoul(av[1], &end, 10);
3534                                argcount = 2;
3535                        }
3536                } else if (skip_prefix(arg, "-graph-width", &arg)) {
3537                        if (*arg == '=')
3538                                graph_width = strtoul(arg + 1, &end, 10);
3539                        else if (!*arg && !av[1])
3540                                die("Option '--stat-graph-width' requires a value");
3541                        else if (!*arg) {
3542                                graph_width = strtoul(av[1], &end, 10);
3543                                argcount = 2;
3544                        }
3545                } else if (skip_prefix(arg, "-count", &arg)) {
3546                        if (*arg == '=')
3547                                count = strtoul(arg + 1, &end, 10);
3548                        else if (!*arg && !av[1])
3549                                die("Option '--stat-count' requires a value");
3550                        else if (!*arg) {
3551                                count = strtoul(av[1], &end, 10);
3552                                argcount = 2;
3553                        }
3554                }
3555                break;
3556        case '=':
3557                width = strtoul(arg+1, &end, 10);
3558                if (*end == ',')
3559                        name_width = strtoul(end+1, &end, 10);
3560                if (*end == ',')
3561                        count = strtoul(end+1, &end, 10);
3562        }
3563
3564        /* Important! This checks all the error cases! */
3565        if (*end)
3566                return 0;
3567        options->output_format |= DIFF_FORMAT_DIFFSTAT;
3568        options->stat_name_width = name_width;
3569        options->stat_graph_width = graph_width;
3570        options->stat_width = width;
3571        options->stat_count = count;
3572        return argcount;
3573}
3574
3575static int parse_dirstat_opt(struct diff_options *options, const char *params)
3576{
3577        struct strbuf errmsg = STRBUF_INIT;
3578        if (parse_dirstat_params(options, params, &errmsg))
3579                die(_("Failed to parse --dirstat/-X option parameter:\n%s"),
3580                    errmsg.buf);
3581        strbuf_release(&errmsg);
3582        /*
3583         * The caller knows a dirstat-related option is given from the command
3584         * line; allow it to say "return this_function();"
3585         */
3586        options->output_format |= DIFF_FORMAT_DIRSTAT;
3587        return 1;
3588}
3589
3590static int parse_submodule_opt(struct diff_options *options, const char *value)
3591{
3592        if (parse_submodule_params(options, value))
3593                die(_("Failed to parse --submodule option parameter: '%s'"),
3594                        value);
3595        return 1;
3596}
3597
3598static const char diff_status_letters[] = {
3599        DIFF_STATUS_ADDED,
3600        DIFF_STATUS_COPIED,
3601        DIFF_STATUS_DELETED,
3602        DIFF_STATUS_MODIFIED,
3603        DIFF_STATUS_RENAMED,
3604        DIFF_STATUS_TYPE_CHANGED,
3605        DIFF_STATUS_UNKNOWN,
3606        DIFF_STATUS_UNMERGED,
3607        DIFF_STATUS_FILTER_AON,
3608        DIFF_STATUS_FILTER_BROKEN,
3609        '\0',
3610};
3611
3612static unsigned int filter_bit['Z' + 1];
3613
3614static void prepare_filter_bits(void)
3615{
3616        int i;
3617
3618        if (!filter_bit[DIFF_STATUS_ADDED]) {
3619                for (i = 0; diff_status_letters[i]; i++)
3620                        filter_bit[(int) diff_status_letters[i]] = (1 << i);
3621        }
3622}
3623
3624static unsigned filter_bit_tst(char status, const struct diff_options *opt)
3625{
3626        return opt->filter & filter_bit[(int) status];
3627}
3628
3629static int parse_diff_filter_opt(const char *optarg, struct diff_options *opt)
3630{
3631        int i, optch;
3632
3633        prepare_filter_bits();
3634
3635        /*
3636         * If there is a negation e.g. 'd' in the input, and we haven't
3637         * initialized the filter field with another --diff-filter, start
3638         * from full set of bits, except for AON.
3639         */
3640        if (!opt->filter) {
3641                for (i = 0; (optch = optarg[i]) != '\0'; i++) {
3642                        if (optch < 'a' || 'z' < optch)
3643                                continue;
3644                        opt->filter = (1 << (ARRAY_SIZE(diff_status_letters) - 1)) - 1;
3645                        opt->filter &= ~filter_bit[DIFF_STATUS_FILTER_AON];
3646                        break;
3647                }
3648        }
3649
3650        for (i = 0; (optch = optarg[i]) != '\0'; i++) {
3651                unsigned int bit;
3652                int negate;
3653
3654                if ('a' <= optch && optch <= 'z') {
3655                        negate = 1;
3656                        optch = toupper(optch);
3657                } else {
3658                        negate = 0;
3659                }
3660
3661                bit = (0 <= optch && optch <= 'Z') ? filter_bit[optch] : 0;
3662                if (!bit)
3663                        return optarg[i];
3664                if (negate)
3665                        opt->filter &= ~bit;
3666                else
3667                        opt->filter |= bit;
3668        }
3669        return 0;
3670}
3671
3672static void enable_patch_output(int *fmt) {
3673        *fmt &= ~DIFF_FORMAT_NO_OUTPUT;
3674        *fmt |= DIFF_FORMAT_PATCH;
3675}
3676
3677static int parse_one_token(const char **arg, const char *token)
3678{
3679        const char *rest;
3680        if (skip_prefix(*arg, token, &rest) && (!*rest || *rest == ',')) {
3681                *arg = rest;
3682                return 1;
3683        }
3684        return 0;
3685}
3686
3687static int parse_ws_error_highlight(struct diff_options *opt, const char *arg)
3688{
3689        const char *orig_arg = arg;
3690        unsigned val = 0;
3691        while (*arg) {
3692                if (parse_one_token(&arg, "none"))
3693                        val = 0;
3694                else if (parse_one_token(&arg, "default"))
3695                        val = WSEH_NEW;
3696                else if (parse_one_token(&arg, "all"))
3697                        val = WSEH_NEW | WSEH_OLD | WSEH_CONTEXT;
3698                else if (parse_one_token(&arg, "new"))
3699                        val |= WSEH_NEW;
3700                else if (parse_one_token(&arg, "old"))
3701                        val |= WSEH_OLD;
3702                else if (parse_one_token(&arg, "context"))
3703                        val |= WSEH_CONTEXT;
3704                else {
3705                        error("unknown value after ws-error-highlight=%.*s",
3706                              (int)(arg - orig_arg), orig_arg);
3707                        return 0;
3708                }
3709                if (*arg)
3710                        arg++;
3711        }
3712        opt->ws_error_highlight = val;
3713        return 1;
3714}
3715
3716int diff_opt_parse(struct diff_options *options,
3717                   const char **av, int ac, const char *prefix)
3718{
3719        const char *arg = av[0];
3720        const char *optarg;
3721        int argcount;
3722
3723        if (!prefix)
3724                prefix = "";
3725
3726        /* Output format options */
3727        if (!strcmp(arg, "-p") || !strcmp(arg, "-u") || !strcmp(arg, "--patch")
3728            || opt_arg(arg, 'U', "unified", &options->context))
3729                enable_patch_output(&options->output_format);
3730        else if (!strcmp(arg, "--raw"))
3731                options->output_format |= DIFF_FORMAT_RAW;
3732        else if (!strcmp(arg, "--patch-with-raw")) {
3733                enable_patch_output(&options->output_format);
3734                options->output_format |= DIFF_FORMAT_RAW;
3735        } else if (!strcmp(arg, "--numstat"))
3736                options->output_format |= DIFF_FORMAT_NUMSTAT;
3737        else if (!strcmp(arg, "--shortstat"))
3738                options->output_format |= DIFF_FORMAT_SHORTSTAT;
3739        else if (!strcmp(arg, "-X") || !strcmp(arg, "--dirstat"))
3740                return parse_dirstat_opt(options, "");
3741        else if (skip_prefix(arg, "-X", &arg))
3742                return parse_dirstat_opt(options, arg);
3743        else if (skip_prefix(arg, "--dirstat=", &arg))
3744                return parse_dirstat_opt(options, arg);
3745        else if (!strcmp(arg, "--cumulative"))
3746                return parse_dirstat_opt(options, "cumulative");
3747        else if (!strcmp(arg, "--dirstat-by-file"))
3748                return parse_dirstat_opt(options, "files");
3749        else if (skip_prefix(arg, "--dirstat-by-file=", &arg)) {
3750                parse_dirstat_opt(options, "files");
3751                return parse_dirstat_opt(options, arg);
3752        }
3753        else if (!strcmp(arg, "--check"))
3754                options->output_format |= DIFF_FORMAT_CHECKDIFF;
3755        else if (!strcmp(arg, "--summary"))
3756                options->output_format |= DIFF_FORMAT_SUMMARY;
3757        else if (!strcmp(arg, "--patch-with-stat")) {
3758                enable_patch_output(&options->output_format);
3759                options->output_format |= DIFF_FORMAT_DIFFSTAT;
3760        } else if (!strcmp(arg, "--name-only"))
3761                options->output_format |= DIFF_FORMAT_NAME;
3762        else if (!strcmp(arg, "--name-status"))
3763                options->output_format |= DIFF_FORMAT_NAME_STATUS;
3764        else if (!strcmp(arg, "-s") || !strcmp(arg, "--no-patch"))
3765                options->output_format |= DIFF_FORMAT_NO_OUTPUT;
3766        else if (starts_with(arg, "--stat"))
3767                /* --stat, --stat-width, --stat-name-width, or --stat-count */
3768                return stat_opt(options, av);
3769
3770        /* renames options */
3771        else if (starts_with(arg, "-B") || starts_with(arg, "--break-rewrites=") ||
3772                 !strcmp(arg, "--break-rewrites")) {
3773                if ((options->break_opt = diff_scoreopt_parse(arg)) == -1)
3774                        return error("invalid argument to -B: %s", arg+2);
3775        }
3776        else if (starts_with(arg, "-M") || starts_with(arg, "--find-renames=") ||
3777                 !strcmp(arg, "--find-renames")) {
3778                if ((options->rename_score = diff_scoreopt_parse(arg)) == -1)
3779                        return error("invalid argument to -M: %s", arg+2);
3780                options->detect_rename = DIFF_DETECT_RENAME;
3781        }
3782        else if (!strcmp(arg, "-D") || !strcmp(arg, "--irreversible-delete")) {
3783                options->irreversible_delete = 1;
3784        }
3785        else if (starts_with(arg, "-C") || starts_with(arg, "--find-copies=") ||
3786                 !strcmp(arg, "--find-copies")) {
3787                if (options->detect_rename == DIFF_DETECT_COPY)
3788                        DIFF_OPT_SET(options, FIND_COPIES_HARDER);
3789                if ((options->rename_score = diff_scoreopt_parse(arg)) == -1)
3790                        return error("invalid argument to -C: %s", arg+2);
3791                options->detect_rename = DIFF_DETECT_COPY;
3792        }
3793        else if (!strcmp(arg, "--no-renames"))
3794                options->detect_rename = 0;
3795        else if (!strcmp(arg, "--rename-empty"))
3796                DIFF_OPT_SET(options, RENAME_EMPTY);
3797        else if (!strcmp(arg, "--no-rename-empty"))
3798                DIFF_OPT_CLR(options, RENAME_EMPTY);
3799        else if (!strcmp(arg, "--relative"))
3800                DIFF_OPT_SET(options, RELATIVE_NAME);
3801        else if (skip_prefix(arg, "--relative=", &arg)) {
3802                DIFF_OPT_SET(options, RELATIVE_NAME);
3803                options->prefix = arg;
3804        }
3805
3806        /* xdiff options */
3807        else if (!strcmp(arg, "--minimal"))
3808                DIFF_XDL_SET(options, NEED_MINIMAL);
3809        else if (!strcmp(arg, "--no-minimal"))
3810                DIFF_XDL_CLR(options, NEED_MINIMAL);
3811        else if (!strcmp(arg, "-w") || !strcmp(arg, "--ignore-all-space"))
3812                DIFF_XDL_SET(options, IGNORE_WHITESPACE);
3813        else if (!strcmp(arg, "-b") || !strcmp(arg, "--ignore-space-change"))
3814                DIFF_XDL_SET(options, IGNORE_WHITESPACE_CHANGE);
3815        else if (!strcmp(arg, "--ignore-space-at-eol"))
3816                DIFF_XDL_SET(options, IGNORE_WHITESPACE_AT_EOL);
3817        else if (!strcmp(arg, "--ignore-blank-lines"))
3818                DIFF_XDL_SET(options, IGNORE_BLANK_LINES);
3819        else if (!strcmp(arg, "--indent-heuristic")) {
3820                DIFF_XDL_SET(options, INDENT_HEURISTIC);
3821                DIFF_XDL_CLR(options, COMPACTION_HEURISTIC);
3822        } else if (!strcmp(arg, "--no-indent-heuristic"))
3823                DIFF_XDL_CLR(options, INDENT_HEURISTIC);
3824        else if (!strcmp(arg, "--compaction-heuristic")) {
3825                DIFF_XDL_SET(options, COMPACTION_HEURISTIC);
3826                DIFF_XDL_CLR(options, INDENT_HEURISTIC);
3827        } else if (!strcmp(arg, "--no-compaction-heuristic"))
3828                DIFF_XDL_CLR(options, COMPACTION_HEURISTIC);
3829        else if (!strcmp(arg, "--patience"))
3830                options->xdl_opts = DIFF_WITH_ALG(options, PATIENCE_DIFF);
3831        else if (!strcmp(arg, "--histogram"))
3832                options->xdl_opts = DIFF_WITH_ALG(options, HISTOGRAM_DIFF);
3833        else if ((argcount = parse_long_opt("diff-algorithm", av, &optarg))) {
3834                long value = parse_algorithm_value(optarg);
3835                if (value < 0)
3836                        return error("option diff-algorithm accepts \"myers\", "
3837                                     "\"minimal\", \"patience\" and \"histogram\"");
3838                /* clear out previous settings */
3839                DIFF_XDL_CLR(options, NEED_MINIMAL);
3840                options->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;
3841                options->xdl_opts |= value;
3842                return argcount;
3843        }
3844
3845        /* flags options */
3846        else if (!strcmp(arg, "--binary")) {
3847                enable_patch_output(&options->output_format);
3848                DIFF_OPT_SET(options, BINARY);
3849        }
3850        else if (!strcmp(arg, "--full-index"))
3851                DIFF_OPT_SET(options, FULL_INDEX);
3852        else if (!strcmp(arg, "-a") || !strcmp(arg, "--text"))
3853                DIFF_OPT_SET(options, TEXT);
3854        else if (!strcmp(arg, "-R"))
3855                DIFF_OPT_SET(options, REVERSE_DIFF);
3856        else if (!strcmp(arg, "--find-copies-harder"))
3857                DIFF_OPT_SET(options, FIND_COPIES_HARDER);
3858        else if (!strcmp(arg, "--follow"))
3859                DIFF_OPT_SET(options, FOLLOW_RENAMES);
3860        else if (!strcmp(arg, "--no-follow")) {
3861                DIFF_OPT_CLR(options, FOLLOW_RENAMES);
3862                DIFF_OPT_CLR(options, DEFAULT_FOLLOW_RENAMES);
3863        } else if (!strcmp(arg, "--color"))
3864                options->use_color = 1;
3865        else if (skip_prefix(arg, "--color=", &arg)) {
3866                int value = git_config_colorbool(NULL, arg);
3867                if (value < 0)
3868                        return error("option `color' expects \"always\", \"auto\", or \"never\"");
3869                options->use_color = value;
3870        }
3871        else if (!strcmp(arg, "--no-color"))
3872                options->use_color = 0;
3873        else if (!strcmp(arg, "--color-words")) {
3874                options->use_color = 1;
3875                options->word_diff = DIFF_WORDS_COLOR;
3876        }
3877        else if (skip_prefix(arg, "--color-words=", &arg)) {
3878                options->use_color = 1;
3879                options->word_diff = DIFF_WORDS_COLOR;
3880                options->word_regex = arg;
3881        }
3882        else if (!strcmp(arg, "--word-diff")) {
3883                if (options->word_diff == DIFF_WORDS_NONE)
3884                        options->word_diff = DIFF_WORDS_PLAIN;
3885        }
3886        else if (skip_prefix(arg, "--word-diff=", &arg)) {
3887                if (!strcmp(arg, "plain"))
3888                        options->word_diff = DIFF_WORDS_PLAIN;
3889                else if (!strcmp(arg, "color")) {
3890                        options->use_color = 1;
3891                        options->word_diff = DIFF_WORDS_COLOR;
3892                }
3893                else if (!strcmp(arg, "porcelain"))
3894                        options->word_diff = DIFF_WORDS_PORCELAIN;
3895                else if (!strcmp(arg, "none"))
3896                        options->word_diff = DIFF_WORDS_NONE;
3897                else
3898                        die("bad --word-diff argument: %s", arg);
3899        }
3900        else if ((argcount = parse_long_opt("word-diff-regex", av, &optarg))) {
3901                if (options->word_diff == DIFF_WORDS_NONE)
3902                        options->word_diff = DIFF_WORDS_PLAIN;
3903                options->word_regex = optarg;
3904                return argcount;
3905        }
3906        else if (!strcmp(arg, "--exit-code"))
3907                DIFF_OPT_SET(options, EXIT_WITH_STATUS);
3908        else if (!strcmp(arg, "--quiet"))
3909                DIFF_OPT_SET(options, QUICK);
3910        else if (!strcmp(arg, "--ext-diff"))
3911                DIFF_OPT_SET(options, ALLOW_EXTERNAL);
3912        else if (!strcmp(arg, "--no-ext-diff"))
3913                DIFF_OPT_CLR(options, ALLOW_EXTERNAL);
3914        else if (!strcmp(arg, "--textconv"))
3915                DIFF_OPT_SET(options, ALLOW_TEXTCONV);
3916        else if (!strcmp(arg, "--no-textconv"))
3917                DIFF_OPT_CLR(options, ALLOW_TEXTCONV);
3918        else if (!strcmp(arg, "--ignore-submodules")) {
3919                DIFF_OPT_SET(options, OVERRIDE_SUBMODULE_CONFIG);
3920                handle_ignore_submodules_arg(options, "all");
3921        } else if (skip_prefix(arg, "--ignore-submodules=", &arg)) {
3922                DIFF_OPT_SET(options, OVERRIDE_SUBMODULE_CONFIG);
3923                handle_ignore_submodules_arg(options, arg);
3924        } else if (!strcmp(arg, "--submodule"))
3925                DIFF_OPT_SET(options, SUBMODULE_LOG);
3926        else if (skip_prefix(arg, "--submodule=", &arg))
3927                return parse_submodule_opt(options, arg);
3928        else if (skip_prefix(arg, "--ws-error-highlight=", &arg))
3929                return parse_ws_error_highlight(options, arg);
3930
3931        /* misc options */
3932        else if (!strcmp(arg, "-z"))
3933                options->line_termination = 0;
3934        else if ((argcount = short_opt('l', av, &optarg))) {
3935                options->rename_limit = strtoul(optarg, NULL, 10);
3936                return argcount;
3937        }
3938        else if ((argcount = short_opt('S', av, &optarg))) {
3939                options->pickaxe = optarg;
3940                options->pickaxe_opts |= DIFF_PICKAXE_KIND_S;
3941                return argcount;
3942        } else if ((argcount = short_opt('G', av, &optarg))) {
3943                options->pickaxe = optarg;
3944                options->pickaxe_opts |= DIFF_PICKAXE_KIND_G;
3945                return argcount;
3946        }
3947        else if (!strcmp(arg, "--pickaxe-all"))
3948                options->pickaxe_opts |= DIFF_PICKAXE_ALL;
3949        else if (!strcmp(arg, "--pickaxe-regex"))
3950                options->pickaxe_opts |= DIFF_PICKAXE_REGEX;
3951        else if ((argcount = short_opt('O', av, &optarg))) {
3952                const char *path = prefix_filename(prefix, strlen(prefix), optarg);
3953                options->orderfile = xstrdup(path);
3954                return argcount;
3955        }
3956        else if ((argcount = parse_long_opt("diff-filter", av, &optarg))) {
3957                int offending = parse_diff_filter_opt(optarg, options);
3958                if (offending)
3959                        die("unknown change class '%c' in --diff-filter=%s",
3960                            offending, optarg);
3961                return argcount;
3962        }
3963        else if (!strcmp(arg, "--abbrev"))
3964                options->abbrev = DEFAULT_ABBREV;
3965        else if (skip_prefix(arg, "--abbrev=", &arg)) {
3966                options->abbrev = strtoul(arg, NULL, 10);
3967                if (options->abbrev < MINIMUM_ABBREV)
3968                        options->abbrev = MINIMUM_ABBREV;
3969                else if (40 < options->abbrev)
3970                        options->abbrev = 40;
3971        }
3972        else if ((argcount = parse_long_opt("src-prefix", av, &optarg))) {
3973                options->a_prefix = optarg;
3974                return argcount;
3975        }
3976        else if ((argcount = parse_long_opt("dst-prefix", av, &optarg))) {
3977                options->b_prefix = optarg;
3978                return argcount;
3979        }
3980        else if (!strcmp(arg, "--no-prefix"))
3981                options->a_prefix = options->b_prefix = "";
3982        else if (opt_arg(arg, '\0', "inter-hunk-context",
3983                         &options->interhunkcontext))
3984                ;
3985        else if (!strcmp(arg, "-W"))
3986                DIFF_OPT_SET(options, FUNCCONTEXT);
3987        else if (!strcmp(arg, "--function-context"))
3988                DIFF_OPT_SET(options, FUNCCONTEXT);
3989        else if (!strcmp(arg, "--no-function-context"))
3990                DIFF_OPT_CLR(options, FUNCCONTEXT);
3991        else if ((argcount = parse_long_opt("output", av, &optarg))) {
3992                const char *path = prefix_filename(prefix, strlen(prefix), optarg);
3993                options->file = fopen(path, "w");
3994                if (!options->file)
3995                        die_errno("Could not open '%s'", path);
3996                options->close_file = 1;
3997                return argcount;
3998        } else
3999                return 0;
4000        return 1;
4001}
4002
4003int parse_rename_score(const char **cp_p)
4004{
4005        unsigned long num, scale;
4006        int ch, dot;
4007        const char *cp = *cp_p;
4008
4009        num = 0;
4010        scale = 1;
4011        dot = 0;
4012        for (;;) {
4013                ch = *cp;
4014                if ( !dot && ch == '.' ) {
4015                        scale = 1;
4016                        dot = 1;
4017                } else if ( ch == '%' ) {
4018                        scale = dot ? scale*100 : 100;
4019                        cp++;   /* % is always at the end */
4020                        break;
4021                } else if ( ch >= '0' && ch <= '9' ) {
4022                        if ( scale < 100000 ) {
4023                                scale *= 10;
4024                                num = (num*10) + (ch-'0');
4025                        }
4026                } else {
4027                        break;
4028                }
4029                cp++;
4030        }
4031        *cp_p = cp;
4032
4033        /* user says num divided by scale and we say internally that
4034         * is MAX_SCORE * num / scale.
4035         */
4036        return (int)((num >= scale) ? MAX_SCORE : (MAX_SCORE * num / scale));
4037}
4038
4039static int diff_scoreopt_parse(const char *opt)
4040{
4041        int opt1, opt2, cmd;
4042
4043        if (*opt++ != '-')
4044                return -1;
4045        cmd = *opt++;
4046        if (cmd == '-') {
4047                /* convert the long-form arguments into short-form versions */
4048                if (skip_prefix(opt, "break-rewrites", &opt)) {
4049                        if (*opt == 0 || *opt++ == '=')
4050                                cmd = 'B';
4051                } else if (skip_prefix(opt, "find-copies", &opt)) {
4052                        if (*opt == 0 || *opt++ == '=')
4053                                cmd = 'C';
4054                } else if (skip_prefix(opt, "find-renames", &opt)) {
4055                        if (*opt == 0 || *opt++ == '=')
4056                                cmd = 'M';
4057                }
4058        }
4059        if (cmd != 'M' && cmd != 'C' && cmd != 'B')
4060                return -1; /* that is not a -M, -C, or -B option */
4061
4062        opt1 = parse_rename_score(&opt);
4063        if (cmd != 'B')
4064                opt2 = 0;
4065        else {
4066                if (*opt == 0)
4067                        opt2 = 0;
4068                else if (*opt != '/')
4069                        return -1; /* we expect -B80/99 or -B80 */
4070                else {
4071                        opt++;
4072                        opt2 = parse_rename_score(&opt);
4073                }
4074        }
4075        if (*opt != 0)
4076                return -1;
4077        return opt1 | (opt2 << 16);
4078}
4079
4080struct diff_queue_struct diff_queued_diff;
4081
4082void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp)
4083{
4084        ALLOC_GROW(queue->queue, queue->nr + 1, queue->alloc);
4085        queue->queue[queue->nr++] = dp;
4086}
4087
4088struct diff_filepair *diff_queue(struct diff_queue_struct *queue,
4089                                 struct diff_filespec *one,
4090                                 struct diff_filespec *two)
4091{
4092        struct diff_filepair *dp = xcalloc(1, sizeof(*dp));
4093        dp->one = one;
4094        dp->two = two;
4095        if (queue)
4096                diff_q(queue, dp);
4097        return dp;
4098}
4099
4100void diff_free_filepair(struct diff_filepair *p)
4101{
4102        free_filespec(p->one);
4103        free_filespec(p->two);
4104        free(p);
4105}
4106
4107/* This is different from find_unique_abbrev() in that
4108 * it stuffs the result with dots for alignment.
4109 */
4110const char *diff_unique_abbrev(const unsigned char *sha1, int len)
4111{
4112        int abblen;
4113        const char *abbrev;
4114        if (len == 40)
4115                return sha1_to_hex(sha1);
4116
4117        abbrev = find_unique_abbrev(sha1, len);
4118        abblen = strlen(abbrev);
4119        if (abblen < 37) {
4120                static char hex[41];
4121                if (len < abblen && abblen <= len + 2)
4122                        xsnprintf(hex, sizeof(hex), "%s%.*s", abbrev, len+3-abblen, "..");
4123                else
4124                        xsnprintf(hex, sizeof(hex), "%s...", abbrev);
4125                return hex;
4126        }
4127        return sha1_to_hex(sha1);
4128}
4129
4130static void diff_flush_raw(struct diff_filepair *p, struct diff_options *opt)
4131{
4132        int line_termination = opt->line_termination;
4133        int inter_name_termination = line_termination ? '\t' : '\0';
4134
4135        fprintf(opt->file, "%s", diff_line_prefix(opt));
4136        if (!(opt->output_format & DIFF_FORMAT_NAME_STATUS)) {
4137                fprintf(opt->file, ":%06o %06o %s ", p->one->mode, p->two->mode,
4138                        diff_unique_abbrev(p->one->sha1, opt->abbrev));
4139                fprintf(opt->file, "%s ", diff_unique_abbrev(p->two->sha1, opt->abbrev));
4140        }
4141        if (p->score) {
4142                fprintf(opt->file, "%c%03d%c", p->status, similarity_index(p),
4143                        inter_name_termination);
4144        } else {
4145                fprintf(opt->file, "%c%c", p->status, inter_name_termination);
4146        }
4147
4148        if (p->status == DIFF_STATUS_COPIED ||
4149            p->status == DIFF_STATUS_RENAMED) {
4150                const char *name_a, *name_b;
4151                name_a = p->one->path;
4152                name_b = p->two->path;
4153                strip_prefix(opt->prefix_length, &name_a, &name_b);
4154                write_name_quoted(name_a, opt->file, inter_name_termination);
4155                write_name_quoted(name_b, opt->file, line_termination);
4156        } else {
4157                const char *name_a, *name_b;
4158                name_a = p->one->mode ? p->one->path : p->two->path;
4159                name_b = NULL;
4160                strip_prefix(opt->prefix_length, &name_a, &name_b);
4161                write_name_quoted(name_a, opt->file, line_termination);
4162        }
4163}
4164
4165int diff_unmodified_pair(struct diff_filepair *p)
4166{
4167        /* This function is written stricter than necessary to support
4168         * the currently implemented transformers, but the idea is to
4169         * let transformers to produce diff_filepairs any way they want,
4170         * and filter and clean them up here before producing the output.
4171         */
4172        struct diff_filespec *one = p->one, *two = p->two;
4173
4174        if (DIFF_PAIR_UNMERGED(p))
4175                return 0; /* unmerged is interesting */
4176
4177        /* deletion, addition, mode or type change
4178         * and rename are all interesting.
4179         */
4180        if (DIFF_FILE_VALID(one) != DIFF_FILE_VALID(two) ||
4181            DIFF_PAIR_MODE_CHANGED(p) ||
4182            strcmp(one->path, two->path))
4183                return 0;
4184
4185        /* both are valid and point at the same path.  that is, we are
4186         * dealing with a change.
4187         */
4188        if (one->sha1_valid && two->sha1_valid &&
4189            !hashcmp(one->sha1, two->sha1) &&
4190            !one->dirty_submodule && !two->dirty_submodule)
4191                return 1; /* no change */
4192        if (!one->sha1_valid && !two->sha1_valid)
4193                return 1; /* both look at the same file on the filesystem. */
4194        return 0;
4195}
4196
4197static void diff_flush_patch(struct diff_filepair *p, struct diff_options *o)
4198{
4199        if (diff_unmodified_pair(p))
4200                return;
4201
4202        if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
4203            (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
4204                return; /* no tree diffs in patch format */
4205
4206        run_diff(p, o);
4207}
4208
4209static void diff_flush_stat(struct diff_filepair *p, struct diff_options *o,
4210                            struct diffstat_t *diffstat)
4211{
4212        if (diff_unmodified_pair(p))
4213                return;
4214
4215        if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
4216            (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
4217                return; /* no useful stat for tree diffs */
4218
4219        run_diffstat(p, o, diffstat);
4220}
4221
4222static void diff_flush_checkdiff(struct diff_filepair *p,
4223                struct diff_options *o)
4224{
4225        if (diff_unmodified_pair(p))
4226                return;
4227
4228        if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
4229            (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
4230                return; /* nothing to check in tree diffs */
4231
4232        run_checkdiff(p, o);
4233}
4234
4235int diff_queue_is_empty(void)
4236{
4237        struct diff_queue_struct *q = &diff_queued_diff;
4238        int i;
4239        for (i = 0; i < q->nr; i++)
4240                if (!diff_unmodified_pair(q->queue[i]))
4241                        return 0;
4242        return 1;
4243}
4244
4245#if DIFF_DEBUG
4246void diff_debug_filespec(struct diff_filespec *s, int x, const char *one)
4247{
4248        fprintf(stderr, "queue[%d] %s (%s) %s %06o %s\n",
4249                x, one ? one : "",
4250                s->path,
4251                DIFF_FILE_VALID(s) ? "valid" : "invalid",
4252                s->mode,
4253                s->sha1_valid ? sha1_to_hex(s->sha1) : "");
4254        fprintf(stderr, "queue[%d] %s size %lu\n",
4255                x, one ? one : "",
4256                s->size);
4257}
4258
4259void diff_debug_filepair(const struct diff_filepair *p, int i)
4260{
4261        diff_debug_filespec(p->one, i, "one");
4262        diff_debug_filespec(p->two, i, "two");
4263        fprintf(stderr, "score %d, status %c rename_used %d broken %d\n",
4264                p->score, p->status ? p->status : '?',
4265                p->one->rename_used, p->broken_pair);
4266}
4267
4268void diff_debug_queue(const char *msg, struct diff_queue_struct *q)
4269{
4270        int i;
4271        if (msg)
4272                fprintf(stderr, "%s\n", msg);
4273        fprintf(stderr, "q->nr = %d\n", q->nr);
4274        for (i = 0; i < q->nr; i++) {
4275                struct diff_filepair *p = q->queue[i];
4276                diff_debug_filepair(p, i);
4277        }
4278}
4279#endif
4280
4281static void diff_resolve_rename_copy(void)
4282{
4283        int i;
4284        struct diff_filepair *p;
4285        struct diff_queue_struct *q = &diff_queued_diff;
4286
4287        diff_debug_queue("resolve-rename-copy", q);
4288
4289        for (i = 0; i < q->nr; i++) {
4290                p = q->queue[i];
4291                p->status = 0; /* undecided */
4292                if (DIFF_PAIR_UNMERGED(p))
4293                        p->status = DIFF_STATUS_UNMERGED;
4294                else if (!DIFF_FILE_VALID(p->one))
4295                        p->status = DIFF_STATUS_ADDED;
4296                else if (!DIFF_FILE_VALID(p->two))
4297                        p->status = DIFF_STATUS_DELETED;
4298                else if (DIFF_PAIR_TYPE_CHANGED(p))
4299                        p->status = DIFF_STATUS_TYPE_CHANGED;
4300
4301                /* from this point on, we are dealing with a pair
4302                 * whose both sides are valid and of the same type, i.e.
4303                 * either in-place edit or rename/copy edit.
4304                 */
4305                else if (DIFF_PAIR_RENAME(p)) {
4306                        /*
4307                         * A rename might have re-connected a broken
4308                         * pair up, causing the pathnames to be the
4309                         * same again. If so, that's not a rename at
4310                         * all, just a modification..
4311                         *
4312                         * Otherwise, see if this source was used for
4313                         * multiple renames, in which case we decrement
4314                         * the count, and call it a copy.
4315                         */
4316                        if (!strcmp(p->one->path, p->two->path))
4317                                p->status = DIFF_STATUS_MODIFIED;
4318                        else if (--p->one->rename_used > 0)
4319                                p->status = DIFF_STATUS_COPIED;
4320                        else
4321                                p->status = DIFF_STATUS_RENAMED;
4322                }
4323                else if (hashcmp(p->one->sha1, p->two->sha1) ||
4324                         p->one->mode != p->two->mode ||
4325                         p->one->dirty_submodule ||
4326                         p->two->dirty_submodule ||
4327                         is_null_sha1(p->one->sha1))
4328                        p->status = DIFF_STATUS_MODIFIED;
4329                else {
4330                        /* This is a "no-change" entry and should not
4331                         * happen anymore, but prepare for broken callers.
4332                         */
4333                        error("feeding unmodified %s to diffcore",
4334                              p->one->path);
4335                        p->status = DIFF_STATUS_UNKNOWN;
4336                }
4337        }
4338        diff_debug_queue("resolve-rename-copy done", q);
4339}
4340
4341static int check_pair_status(struct diff_filepair *p)
4342{
4343        switch (p->status) {
4344        case DIFF_STATUS_UNKNOWN:
4345                return 0;
4346        case 0:
4347                die("internal error in diff-resolve-rename-copy");
4348        default:
4349                return 1;
4350        }
4351}
4352
4353static void flush_one_pair(struct diff_filepair *p, struct diff_options *opt)
4354{
4355        int fmt = opt->output_format;
4356
4357        if (fmt & DIFF_FORMAT_CHECKDIFF)
4358                diff_flush_checkdiff(p, opt);
4359        else if (fmt & (DIFF_FORMAT_RAW | DIFF_FORMAT_NAME_STATUS))
4360                diff_flush_raw(p, opt);
4361        else if (fmt & DIFF_FORMAT_NAME) {
4362                const char *name_a, *name_b;
4363                name_a = p->two->path;
4364                name_b = NULL;
4365                strip_prefix(opt->prefix_length, &name_a, &name_b);
4366                write_name_quoted(name_a, opt->file, opt->line_termination);
4367        }
4368}
4369
4370static void show_file_mode_name(FILE *file, const char *newdelete, struct diff_filespec *fs)
4371{
4372        if (fs->mode)
4373                fprintf(file, " %s mode %06o ", newdelete, fs->mode);
4374        else
4375                fprintf(file, " %s ", newdelete);
4376        write_name_quoted(fs->path, file, '\n');
4377}
4378
4379
4380static void show_mode_change(FILE *file, struct diff_filepair *p, int show_name,
4381                const char *line_prefix)
4382{
4383        if (p->one->mode && p->two->mode && p->one->mode != p->two->mode) {
4384                fprintf(file, "%s mode change %06o => %06o%c", line_prefix, p->one->mode,
4385                        p->two->mode, show_name ? ' ' : '\n');
4386                if (show_name) {
4387                        write_name_quoted(p->two->path, file, '\n');
4388                }
4389        }
4390}
4391
4392static void show_rename_copy(FILE *file, const char *renamecopy, struct diff_filepair *p,
4393                        const char *line_prefix)
4394{
4395        char *names = pprint_rename(p->one->path, p->two->path);
4396
4397        fprintf(file, " %s %s (%d%%)\n", renamecopy, names, similarity_index(p));
4398        free(names);
4399        show_mode_change(file, p, 0, line_prefix);
4400}
4401
4402static void diff_summary(struct diff_options *opt, struct diff_filepair *p)
4403{
4404        FILE *file = opt->file;
4405        const char *line_prefix = diff_line_prefix(opt);
4406
4407        switch(p->status) {
4408        case DIFF_STATUS_DELETED:
4409                fputs(line_prefix, file);
4410                show_file_mode_name(file, "delete", p->one);
4411                break;
4412        case DIFF_STATUS_ADDED:
4413                fputs(line_prefix, file);
4414                show_file_mode_name(file, "create", p->two);
4415                break;
4416        case DIFF_STATUS_COPIED:
4417                fputs(line_prefix, file);
4418                show_rename_copy(file, "copy", p, line_prefix);
4419                break;
4420        case DIFF_STATUS_RENAMED:
4421                fputs(line_prefix, file);
4422                show_rename_copy(file, "rename", p, line_prefix);
4423                break;
4424        default:
4425                if (p->score) {
4426                        fprintf(file, "%s rewrite ", line_prefix);
4427                        write_name_quoted(p->two->path, file, ' ');
4428                        fprintf(file, "(%d%%)\n", similarity_index(p));
4429                }
4430                show_mode_change(file, p, !p->score, line_prefix);
4431                break;
4432        }
4433}
4434
4435struct patch_id_t {
4436        git_SHA_CTX *ctx;
4437        int patchlen;
4438};
4439
4440static int remove_space(char *line, int len)
4441{
4442        int i;
4443        char *dst = line;
4444        unsigned char c;
4445
4446        for (i = 0; i < len; i++)
4447                if (!isspace((c = line[i])))
4448                        *dst++ = c;
4449
4450        return dst - line;
4451}
4452
4453static void patch_id_consume(void *priv, char *line, unsigned long len)
4454{
4455        struct patch_id_t *data = priv;
4456        int new_len;
4457
4458        /* Ignore line numbers when computing the SHA1 of the patch */
4459        if (starts_with(line, "@@ -"))
4460                return;
4461
4462        new_len = remove_space(line, len);
4463
4464        git_SHA1_Update(data->ctx, line, new_len);
4465        data->patchlen += new_len;
4466}
4467
4468/* returns 0 upon success, and writes result into sha1 */
4469static int diff_get_patch_id(struct diff_options *options, unsigned char *sha1)
4470{
4471        struct diff_queue_struct *q = &diff_queued_diff;
4472        int i;
4473        git_SHA_CTX ctx;
4474        struct patch_id_t data;
4475        char buffer[PATH_MAX * 4 + 20];
4476
4477        git_SHA1_Init(&ctx);
4478        memset(&data, 0, sizeof(struct patch_id_t));
4479        data.ctx = &ctx;
4480
4481        for (i = 0; i < q->nr; i++) {
4482                xpparam_t xpp;
4483                xdemitconf_t xecfg;
4484                mmfile_t mf1, mf2;
4485                struct diff_filepair *p = q->queue[i];
4486                int len1, len2;
4487
4488                memset(&xpp, 0, sizeof(xpp));
4489                memset(&xecfg, 0, sizeof(xecfg));
4490                if (p->status == 0)
4491                        return error("internal diff status error");
4492                if (p->status == DIFF_STATUS_UNKNOWN)
4493                        continue;
4494                if (diff_unmodified_pair(p))
4495                        continue;
4496                if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
4497                    (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
4498                        continue;
4499                if (DIFF_PAIR_UNMERGED(p))
4500                        continue;
4501
4502                diff_fill_sha1_info(p->one);
4503                diff_fill_sha1_info(p->two);
4504                if (fill_mmfile(&mf1, p->one) < 0 ||
4505                                fill_mmfile(&mf2, p->two) < 0)
4506                        return error("unable to read files to diff");
4507
4508                len1 = remove_space(p->one->path, strlen(p->one->path));
4509                len2 = remove_space(p->two->path, strlen(p->two->path));
4510                if (p->one->mode == 0)
4511                        len1 = snprintf(buffer, sizeof(buffer),
4512                                        "diff--gita/%.*sb/%.*s"
4513                                        "newfilemode%06o"
4514                                        "---/dev/null"
4515                                        "+++b/%.*s",
4516                                        len1, p->one->path,
4517                                        len2, p->two->path,
4518                                        p->two->mode,
4519                                        len2, p->two->path);
4520                else if (p->two->mode == 0)
4521                        len1 = snprintf(buffer, sizeof(buffer),
4522                                        "diff--gita/%.*sb/%.*s"
4523                                        "deletedfilemode%06o"
4524                                        "---a/%.*s"
4525                                        "+++/dev/null",
4526                                        len1, p->one->path,
4527                                        len2, p->two->path,
4528                                        p->one->mode,
4529                                        len1, p->one->path);
4530                else
4531                        len1 = snprintf(buffer, sizeof(buffer),
4532                                        "diff--gita/%.*sb/%.*s"
4533                                        "---a/%.*s"
4534                                        "+++b/%.*s",
4535                                        len1, p->one->path,
4536                                        len2, p->two->path,
4537                                        len1, p->one->path,
4538                                        len2, p->two->path);
4539                git_SHA1_Update(&ctx, buffer, len1);
4540
4541                if (diff_filespec_is_binary(p->one) ||
4542                    diff_filespec_is_binary(p->two)) {
4543                        git_SHA1_Update(&ctx, sha1_to_hex(p->one->sha1), 40);
4544                        git_SHA1_Update(&ctx, sha1_to_hex(p->two->sha1), 40);
4545                        continue;
4546                }
4547
4548                xpp.flags = 0;
4549                xecfg.ctxlen = 3;
4550                xecfg.flags = 0;
4551                if (xdi_diff_outf(&mf1, &mf2, patch_id_consume, &data,
4552                                  &xpp, &xecfg))
4553                        return error("unable to generate patch-id diff for %s",
4554                                     p->one->path);
4555        }
4556
4557        git_SHA1_Final(sha1, &ctx);
4558        return 0;
4559}
4560
4561int diff_flush_patch_id(struct diff_options *options, unsigned char *sha1)
4562{
4563        struct diff_queue_struct *q = &diff_queued_diff;
4564        int i;
4565        int result = diff_get_patch_id(options, sha1);
4566
4567        for (i = 0; i < q->nr; i++)
4568                diff_free_filepair(q->queue[i]);
4569
4570        free(q->queue);
4571        DIFF_QUEUE_CLEAR(q);
4572
4573        return result;
4574}
4575
4576static int is_summary_empty(const struct diff_queue_struct *q)
4577{
4578        int i;
4579
4580        for (i = 0; i < q->nr; i++) {
4581                const struct diff_filepair *p = q->queue[i];
4582
4583                switch (p->status) {
4584                case DIFF_STATUS_DELETED:
4585                case DIFF_STATUS_ADDED:
4586                case DIFF_STATUS_COPIED:
4587                case DIFF_STATUS_RENAMED:
4588                        return 0;
4589                default:
4590                        if (p->score)
4591                                return 0;
4592                        if (p->one->mode && p->two->mode &&
4593                            p->one->mode != p->two->mode)
4594                                return 0;
4595                        break;
4596                }
4597        }
4598        return 1;
4599}
4600
4601static const char rename_limit_warning[] =
4602"inexact rename detection was skipped due to too many files.";
4603
4604static const char degrade_cc_to_c_warning[] =
4605"only found copies from modified paths due to too many files.";
4606
4607static const char rename_limit_advice[] =
4608"you may want to set your %s variable to at least "
4609"%d and retry the command.";
4610
4611void diff_warn_rename_limit(const char *varname, int needed, int degraded_cc)
4612{
4613        if (degraded_cc)
4614                warning(degrade_cc_to_c_warning);
4615        else if (needed)
4616                warning(rename_limit_warning);
4617        else
4618                return;
4619        if (0 < needed && needed < 32767)
4620                warning(rename_limit_advice, varname, needed);
4621}
4622
4623void diff_flush(struct diff_options *options)
4624{
4625        struct diff_queue_struct *q = &diff_queued_diff;
4626        int i, output_format = options->output_format;
4627        int separator = 0;
4628        int dirstat_by_line = 0;
4629
4630        /*
4631         * Order: raw, stat, summary, patch
4632         * or:    name/name-status/checkdiff (other bits clear)
4633         */
4634        if (!q->nr)
4635                goto free_queue;
4636
4637        if (output_format & (DIFF_FORMAT_RAW |
4638                             DIFF_FORMAT_NAME |
4639                             DIFF_FORMAT_NAME_STATUS |
4640                             DIFF_FORMAT_CHECKDIFF)) {
4641                for (i = 0; i < q->nr; i++) {
4642                        struct diff_filepair *p = q->queue[i];
4643                        if (check_pair_status(p))
4644                                flush_one_pair(p, options);
4645                }
4646                separator++;
4647        }
4648
4649        if (output_format & DIFF_FORMAT_DIRSTAT && DIFF_OPT_TST(options, DIRSTAT_BY_LINE))
4650                dirstat_by_line = 1;
4651
4652        if (output_format & (DIFF_FORMAT_DIFFSTAT|DIFF_FORMAT_SHORTSTAT|DIFF_FORMAT_NUMSTAT) ||
4653            dirstat_by_line) {
4654                struct diffstat_t diffstat;
4655
4656                memset(&diffstat, 0, sizeof(struct diffstat_t));
4657                for (i = 0; i < q->nr; i++) {
4658                        struct diff_filepair *p = q->queue[i];
4659                        if (check_pair_status(p))
4660                                diff_flush_stat(p, options, &diffstat);
4661                }
4662                if (output_format & DIFF_FORMAT_NUMSTAT)
4663                        show_numstat(&diffstat, options);
4664                if (output_format & DIFF_FORMAT_DIFFSTAT)
4665                        show_stats(&diffstat, options);
4666                if (output_format & DIFF_FORMAT_SHORTSTAT)
4667                        show_shortstats(&diffstat, options);
4668                if (output_format & DIFF_FORMAT_DIRSTAT && dirstat_by_line)
4669                        show_dirstat_by_line(&diffstat, options);
4670                free_diffstat_info(&diffstat);
4671                separator++;
4672        }
4673        if ((output_format & DIFF_FORMAT_DIRSTAT) && !dirstat_by_line)
4674                show_dirstat(options);
4675
4676        if (output_format & DIFF_FORMAT_SUMMARY && !is_summary_empty(q)) {
4677                for (i = 0; i < q->nr; i++) {
4678                        diff_summary(options, q->queue[i]);
4679                }
4680                separator++;
4681        }
4682
4683        if (output_format & DIFF_FORMAT_NO_OUTPUT &&
4684            DIFF_OPT_TST(options, EXIT_WITH_STATUS) &&
4685            DIFF_OPT_TST(options, DIFF_FROM_CONTENTS)) {
4686                /*
4687                 * run diff_flush_patch for the exit status. setting
4688                 * options->file to /dev/null should be safe, because we
4689                 * aren't supposed to produce any output anyway.
4690                 */
4691                if (options->close_file)
4692                        fclose(options->file);
4693                options->file = fopen("/dev/null", "w");
4694                if (!options->file)
4695                        die_errno("Could not open /dev/null");
4696                options->close_file = 1;
4697                for (i = 0; i < q->nr; i++) {
4698                        struct diff_filepair *p = q->queue[i];
4699                        if (check_pair_status(p))
4700                                diff_flush_patch(p, options);
4701                        if (options->found_changes)
4702                                break;
4703                }
4704        }
4705
4706        if (output_format & DIFF_FORMAT_PATCH) {
4707                if (separator) {
4708                        fprintf(options->file, "%s%c",
4709                                diff_line_prefix(options),
4710                                options->line_termination);
4711                        if (options->stat_sep) {
4712                                /* attach patch instead of inline */
4713                                fputs(options->stat_sep, options->file);
4714                        }
4715                }
4716
4717                for (i = 0; i < q->nr; i++) {
4718                        struct diff_filepair *p = q->queue[i];
4719                        if (check_pair_status(p))
4720                                diff_flush_patch(p, options);
4721                }
4722        }
4723
4724        if (output_format & DIFF_FORMAT_CALLBACK)
4725                options->format_callback(q, options, options->format_callback_data);
4726
4727        for (i = 0; i < q->nr; i++)
4728                diff_free_filepair(q->queue[i]);
4729free_queue:
4730        free(q->queue);
4731        DIFF_QUEUE_CLEAR(q);
4732        if (options->close_file)
4733                fclose(options->file);
4734
4735        /*
4736         * Report the content-level differences with HAS_CHANGES;
4737         * diff_addremove/diff_change does not set the bit when
4738         * DIFF_FROM_CONTENTS is in effect (e.g. with -w).
4739         */
4740        if (DIFF_OPT_TST(options, DIFF_FROM_CONTENTS)) {
4741                if (options->found_changes)
4742                        DIFF_OPT_SET(options, HAS_CHANGES);
4743                else
4744                        DIFF_OPT_CLR(options, HAS_CHANGES);
4745        }
4746}
4747
4748static int match_filter(const struct diff_options *options, const struct diff_filepair *p)
4749{
4750        return (((p->status == DIFF_STATUS_MODIFIED) &&
4751                 ((p->score &&
4752                   filter_bit_tst(DIFF_STATUS_FILTER_BROKEN, options)) ||
4753                  (!p->score &&
4754                   filter_bit_tst(DIFF_STATUS_MODIFIED, options)))) ||
4755                ((p->status != DIFF_STATUS_MODIFIED) &&
4756                 filter_bit_tst(p->status, options)));
4757}
4758
4759static void diffcore_apply_filter(struct diff_options *options)
4760{
4761        int i;
4762        struct diff_queue_struct *q = &diff_queued_diff;
4763        struct diff_queue_struct outq;
4764
4765        DIFF_QUEUE_CLEAR(&outq);
4766
4767        if (!options->filter)
4768                return;
4769
4770        if (filter_bit_tst(DIFF_STATUS_FILTER_AON, options)) {
4771                int found;
4772                for (i = found = 0; !found && i < q->nr; i++) {
4773                        if (match_filter(options, q->queue[i]))
4774                                found++;
4775                }
4776                if (found)
4777                        return;
4778
4779                /* otherwise we will clear the whole queue
4780                 * by copying the empty outq at the end of this
4781                 * function, but first clear the current entries
4782                 * in the queue.
4783                 */
4784                for (i = 0; i < q->nr; i++)
4785                        diff_free_filepair(q->queue[i]);
4786        }
4787        else {
4788                /* Only the matching ones */
4789                for (i = 0; i < q->nr; i++) {
4790                        struct diff_filepair *p = q->queue[i];
4791                        if (match_filter(options, p))
4792                                diff_q(&outq, p);
4793                        else
4794                                diff_free_filepair(p);
4795                }
4796        }
4797        free(q->queue);
4798        *q = outq;
4799}
4800
4801/* Check whether two filespecs with the same mode and size are identical */
4802static int diff_filespec_is_identical(struct diff_filespec *one,
4803                                      struct diff_filespec *two)
4804{
4805        if (S_ISGITLINK(one->mode))
4806                return 0;
4807        if (diff_populate_filespec(one, 0))
4808                return 0;
4809        if (diff_populate_filespec(two, 0))
4810                return 0;
4811        return !memcmp(one->data, two->data, one->size);
4812}
4813
4814static int diff_filespec_check_stat_unmatch(struct diff_filepair *p)
4815{
4816        if (p->done_skip_stat_unmatch)
4817                return p->skip_stat_unmatch_result;
4818
4819        p->done_skip_stat_unmatch = 1;
4820        p->skip_stat_unmatch_result = 0;
4821        /*
4822         * 1. Entries that come from stat info dirtiness
4823         *    always have both sides (iow, not create/delete),
4824         *    one side of the object name is unknown, with
4825         *    the same mode and size.  Keep the ones that
4826         *    do not match these criteria.  They have real
4827         *    differences.
4828         *
4829         * 2. At this point, the file is known to be modified,
4830         *    with the same mode and size, and the object
4831         *    name of one side is unknown.  Need to inspect
4832         *    the identical contents.
4833         */
4834        if (!DIFF_FILE_VALID(p->one) || /* (1) */
4835            !DIFF_FILE_VALID(p->two) ||
4836            (p->one->sha1_valid && p->two->sha1_valid) ||
4837            (p->one->mode != p->two->mode) ||
4838            diff_populate_filespec(p->one, CHECK_SIZE_ONLY) ||
4839            diff_populate_filespec(p->two, CHECK_SIZE_ONLY) ||
4840            (p->one->size != p->two->size) ||
4841            !diff_filespec_is_identical(p->one, p->two)) /* (2) */
4842                p->skip_stat_unmatch_result = 1;
4843        return p->skip_stat_unmatch_result;
4844}
4845
4846static void diffcore_skip_stat_unmatch(struct diff_options *diffopt)
4847{
4848        int i;
4849        struct diff_queue_struct *q = &diff_queued_diff;
4850        struct diff_queue_struct outq;
4851        DIFF_QUEUE_CLEAR(&outq);
4852
4853        for (i = 0; i < q->nr; i++) {
4854                struct diff_filepair *p = q->queue[i];
4855
4856                if (diff_filespec_check_stat_unmatch(p))
4857                        diff_q(&outq, p);
4858                else {
4859                        /*
4860                         * The caller can subtract 1 from skip_stat_unmatch
4861                         * to determine how many paths were dirty only
4862                         * due to stat info mismatch.
4863                         */
4864                        if (!DIFF_OPT_TST(diffopt, NO_INDEX))
4865                                diffopt->skip_stat_unmatch++;
4866                        diff_free_filepair(p);
4867                }
4868        }
4869        free(q->queue);
4870        *q = outq;
4871}
4872
4873static int diffnamecmp(const void *a_, const void *b_)
4874{
4875        const struct diff_filepair *a = *((const struct diff_filepair **)a_);
4876        const struct diff_filepair *b = *((const struct diff_filepair **)b_);
4877        const char *name_a, *name_b;
4878
4879        name_a = a->one ? a->one->path : a->two->path;
4880        name_b = b->one ? b->one->path : b->two->path;
4881        return strcmp(name_a, name_b);
4882}
4883
4884void diffcore_fix_diff_index(struct diff_options *options)
4885{
4886        struct diff_queue_struct *q = &diff_queued_diff;
4887        qsort(q->queue, q->nr, sizeof(q->queue[0]), diffnamecmp);
4888}
4889
4890void diffcore_std(struct diff_options *options)
4891{
4892        /* NOTE please keep the following in sync with diff_tree_combined() */
4893        if (options->skip_stat_unmatch)
4894                diffcore_skip_stat_unmatch(options);
4895        if (!options->found_follow) {
4896                /* See try_to_follow_renames() in tree-diff.c */
4897                if (options->break_opt != -1)
4898                        diffcore_break(options->break_opt);
4899                if (options->detect_rename)
4900                        diffcore_rename(options);
4901                if (options->break_opt != -1)
4902                        diffcore_merge_broken();
4903        }
4904        if (options->pickaxe)
4905                diffcore_pickaxe(options);
4906        if (options->orderfile)
4907                diffcore_order(options->orderfile);
4908        if (!options->found_follow)
4909                /* See try_to_follow_renames() in tree-diff.c */
4910                diff_resolve_rename_copy();
4911        diffcore_apply_filter(options);
4912
4913        if (diff_queued_diff.nr && !DIFF_OPT_TST(options, DIFF_FROM_CONTENTS))
4914                DIFF_OPT_SET(options, HAS_CHANGES);
4915        else
4916                DIFF_OPT_CLR(options, HAS_CHANGES);
4917
4918        options->found_follow = 0;
4919}
4920
4921int diff_result_code(struct diff_options *opt, int status)
4922{
4923        int result = 0;
4924
4925        diff_warn_rename_limit("diff.renameLimit",
4926                               opt->needed_rename_limit,
4927                               opt->degraded_cc_to_c);
4928        if (!DIFF_OPT_TST(opt, EXIT_WITH_STATUS) &&
4929            !(opt->output_format & DIFF_FORMAT_CHECKDIFF))
4930                return status;
4931        if (DIFF_OPT_TST(opt, EXIT_WITH_STATUS) &&
4932            DIFF_OPT_TST(opt, HAS_CHANGES))
4933                result |= 01;
4934        if ((opt->output_format & DIFF_FORMAT_CHECKDIFF) &&
4935            DIFF_OPT_TST(opt, CHECK_FAILED))
4936                result |= 02;
4937        return result;
4938}
4939
4940int diff_can_quit_early(struct diff_options *opt)
4941{
4942        return (DIFF_OPT_TST(opt, QUICK) &&
4943                !opt->filter &&
4944                DIFF_OPT_TST(opt, HAS_CHANGES));
4945}
4946
4947/*
4948 * Shall changes to this submodule be ignored?
4949 *
4950 * Submodule changes can be configured to be ignored separately for each path,
4951 * but that configuration can be overridden from the command line.
4952 */
4953static int is_submodule_ignored(const char *path, struct diff_options *options)
4954{
4955        int ignored = 0;
4956        unsigned orig_flags = options->flags;
4957        if (!DIFF_OPT_TST(options, OVERRIDE_SUBMODULE_CONFIG))
4958                set_diffopt_flags_from_submodule_config(options, path);
4959        if (DIFF_OPT_TST(options, IGNORE_SUBMODULES))
4960                ignored = 1;
4961        options->flags = orig_flags;
4962        return ignored;
4963}
4964
4965void diff_addremove(struct diff_options *options,
4966                    int addremove, unsigned mode,
4967                    const unsigned char *sha1,
4968                    int sha1_valid,
4969                    const char *concatpath, unsigned dirty_submodule)
4970{
4971        struct diff_filespec *one, *two;
4972
4973        if (S_ISGITLINK(mode) && is_submodule_ignored(concatpath, options))
4974                return;
4975
4976        /* This may look odd, but it is a preparation for
4977         * feeding "there are unchanged files which should
4978         * not produce diffs, but when you are doing copy
4979         * detection you would need them, so here they are"
4980         * entries to the diff-core.  They will be prefixed
4981         * with something like '=' or '*' (I haven't decided
4982         * which but should not make any difference).
4983         * Feeding the same new and old to diff_change()
4984         * also has the same effect.
4985         * Before the final output happens, they are pruned after
4986         * merged into rename/copy pairs as appropriate.
4987         */
4988        if (DIFF_OPT_TST(options, REVERSE_DIFF))
4989                addremove = (addremove == '+' ? '-' :
4990                             addremove == '-' ? '+' : addremove);
4991
4992        if (options->prefix &&
4993            strncmp(concatpath, options->prefix, options->prefix_length))
4994                return;
4995
4996        one = alloc_filespec(concatpath);
4997        two = alloc_filespec(concatpath);
4998
4999        if (addremove != '+')
5000                fill_filespec(one, sha1, sha1_valid, mode);
5001        if (addremove != '-') {
5002                fill_filespec(two, sha1, sha1_valid, mode);
5003                two->dirty_submodule = dirty_submodule;
5004        }
5005
5006        diff_queue(&diff_queued_diff, one, two);
5007        if (!DIFF_OPT_TST(options, DIFF_FROM_CONTENTS))
5008                DIFF_OPT_SET(options, HAS_CHANGES);
5009}
5010
5011void diff_change(struct diff_options *options,
5012                 unsigned old_mode, unsigned new_mode,
5013                 const unsigned char *old_sha1,
5014                 const unsigned char *new_sha1,
5015                 int old_sha1_valid, int new_sha1_valid,
5016                 const char *concatpath,
5017                 unsigned old_dirty_submodule, unsigned new_dirty_submodule)
5018{
5019        struct diff_filespec *one, *two;
5020        struct diff_filepair *p;
5021
5022        if (S_ISGITLINK(old_mode) && S_ISGITLINK(new_mode) &&
5023            is_submodule_ignored(concatpath, options))
5024                return;
5025
5026        if (DIFF_OPT_TST(options, REVERSE_DIFF)) {
5027                unsigned tmp;
5028                const unsigned char *tmp_c;
5029                tmp = old_mode; old_mode = new_mode; new_mode = tmp;
5030                tmp_c = old_sha1; old_sha1 = new_sha1; new_sha1 = tmp_c;
5031                tmp = old_sha1_valid; old_sha1_valid = new_sha1_valid;
5032                        new_sha1_valid = tmp;
5033                tmp = old_dirty_submodule; old_dirty_submodule = new_dirty_submodule;
5034                        new_dirty_submodule = tmp;
5035        }
5036
5037        if (options->prefix &&
5038            strncmp(concatpath, options->prefix, options->prefix_length))
5039                return;
5040
5041        one = alloc_filespec(concatpath);
5042        two = alloc_filespec(concatpath);
5043        fill_filespec(one, old_sha1, old_sha1_valid, old_mode);
5044        fill_filespec(two, new_sha1, new_sha1_valid, new_mode);
5045        one->dirty_submodule = old_dirty_submodule;
5046        two->dirty_submodule = new_dirty_submodule;
5047        p = diff_queue(&diff_queued_diff, one, two);
5048
5049        if (DIFF_OPT_TST(options, DIFF_FROM_CONTENTS))
5050                return;
5051
5052        if (DIFF_OPT_TST(options, QUICK) && options->skip_stat_unmatch &&
5053            !diff_filespec_check_stat_unmatch(p))
5054                return;
5055
5056        DIFF_OPT_SET(options, HAS_CHANGES);
5057}
5058
5059struct diff_filepair *diff_unmerge(struct diff_options *options, const char *path)
5060{
5061        struct diff_filepair *pair;
5062        struct diff_filespec *one, *two;
5063
5064        if (options->prefix &&
5065            strncmp(path, options->prefix, options->prefix_length))
5066                return NULL;
5067
5068        one = alloc_filespec(path);
5069        two = alloc_filespec(path);
5070        pair = diff_queue(&diff_queued_diff, one, two);
5071        pair->is_unmerged = 1;
5072        return pair;
5073}
5074
5075static char *run_textconv(const char *pgm, struct diff_filespec *spec,
5076                size_t *outsize)
5077{
5078        struct diff_tempfile *temp;
5079        const char *argv[3];
5080        const char **arg = argv;
5081        struct child_process child = CHILD_PROCESS_INIT;
5082        struct strbuf buf = STRBUF_INIT;
5083        int err = 0;
5084
5085        temp = prepare_temp_file(spec->path, spec);
5086        *arg++ = pgm;
5087        *arg++ = temp->name;
5088        *arg = NULL;
5089
5090        child.use_shell = 1;
5091        child.argv = argv;
5092        child.out = -1;
5093        if (start_command(&child)) {
5094                remove_tempfile();
5095                return NULL;
5096        }
5097
5098        if (strbuf_read(&buf, child.out, 0) < 0)
5099                err = error("error reading from textconv command '%s'", pgm);
5100        close(child.out);
5101
5102        if (finish_command(&child) || err) {
5103                strbuf_release(&buf);
5104                remove_tempfile();
5105                return NULL;
5106        }
5107        remove_tempfile();
5108
5109        return strbuf_detach(&buf, outsize);
5110}
5111
5112size_t fill_textconv(struct userdiff_driver *driver,
5113                     struct diff_filespec *df,
5114                     char **outbuf)
5115{
5116        size_t size;
5117
5118        if (!driver) {
5119                if (!DIFF_FILE_VALID(df)) {
5120                        *outbuf = "";
5121                        return 0;
5122                }
5123                if (diff_populate_filespec(df, 0))
5124                        die("unable to read files to diff");
5125                *outbuf = df->data;
5126                return df->size;
5127        }
5128
5129        if (!driver->textconv)
5130                die("BUG: fill_textconv called with non-textconv driver");
5131
5132        if (driver->textconv_cache && df->sha1_valid) {
5133                *outbuf = notes_cache_get(driver->textconv_cache, df->sha1,
5134                                          &size);
5135                if (*outbuf)
5136                        return size;
5137        }
5138
5139        *outbuf = run_textconv(driver->textconv, df, &size);
5140        if (!*outbuf)
5141                die("unable to read files to diff");
5142
5143        if (driver->textconv_cache && df->sha1_valid) {
5144                /* ignore errors, as we might be in a readonly repository */
5145                notes_cache_put(driver->textconv_cache, df->sha1, *outbuf,
5146                                size);
5147                /*
5148                 * we could save up changes and flush them all at the end,
5149                 * but we would need an extra call after all diffing is done.
5150                 * Since generating a cache entry is the slow path anyway,
5151                 * this extra overhead probably isn't a big deal.
5152                 */
5153                notes_cache_write(driver->textconv_cache);
5154        }
5155
5156        return size;
5157}
5158
5159void setup_diff_pager(struct diff_options *opt)
5160{
5161        /*
5162         * If the user asked for our exit code, then either they want --quiet
5163         * or --exit-code. We should definitely not bother with a pager in the
5164         * former case, as we will generate no output. Since we still properly
5165         * report our exit code even when a pager is run, we _could_ run a
5166         * pager with --exit-code. But since we have not done so historically,
5167         * and because it is easy to find people oneline advising "git diff
5168         * --exit-code" in hooks and other scripts, we do not do so.
5169         */
5170        if (!DIFF_OPT_TST(opt, EXIT_WITH_STATUS) &&
5171            check_pager_config("diff") != 0)
5172                setup_pager();
5173}