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