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