diff.c

   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 "xdiff/xdiff.h"
  12
  13 static const char *diff_opts = "-pu";
  14
  15 static int use_size_cache;
  16
  17 int diff_rename_limit_default = -1;
  18
  19 int git_diff_config(const char *var, const char *value)
  20 {
  21         if (!strcmp(var, "diff.renamelimit")) {
  22                 diff_rename_limit_default = git_config_int(var, value);
  23                 return 0;
  24         }
  25
  26         return git_default_config(var, value);
  27 }
  28
  29 static char *quote_one(const char *str)
  30 {
  31         int needlen;
  32         char *xp;
  33
  34         if (!str)
  35                 return NULL;
  36         needlen = quote_c_style(str, NULL, NULL, 0);
  37         if (!needlen)
  38                 return strdup(str);
  39         xp = xmalloc(needlen + 1);
  40         quote_c_style(str, xp, NULL, 0);
  41         return xp;
  42 }
  43
  44 static char *quote_two(const char *one, const char *two)
  45 {
  46         int need_one = quote_c_style(one, NULL, NULL, 1);
  47         int need_two = quote_c_style(two, NULL, NULL, 1);
  48         char *xp;
  49
  50         if (need_one + need_two) {
  51                 if (!need_one) need_one = strlen(one);
  52                 if (!need_two) need_one = strlen(two);
  53
  54                 xp = xmalloc(need_one + need_two + 3);
  55                 xp[0] = '"';
  56                 quote_c_style(one, xp + 1, NULL, 1);
  57                 quote_c_style(two, xp + need_one + 1, NULL, 1);
  58                 strcpy(xp + need_one + need_two + 1, "\"");
  59                 return xp;
  60         }
  61         need_one = strlen(one);
  62         need_two = strlen(two);
  63         xp = xmalloc(need_one + need_two + 1);
  64         strcpy(xp, one);
  65         strcpy(xp + need_one, two);
  66         return xp;
  67 }
  68
  69 static const char *external_diff(void)
  70 {
  71         static const char *external_diff_cmd = NULL;
  72         static int done_preparing = 0;
  73         const char *env_diff_opts;
  74
  75         if (done_preparing)
  76                 return external_diff_cmd;
  77
  78         /*
  79          * Default values above are meant to match the
  80          * Linux kernel development style.  Examples of
  81          * alternative styles you can specify via environment
  82          * variables are:
  83          *
  84          * GIT_DIFF_OPTS="-c";
  85          */
  86         external_diff_cmd = getenv("GIT_EXTERNAL_DIFF");
  87
  88         /* In case external diff fails... */
  89         env_diff_opts = getenv("GIT_DIFF_OPTS");
  90         if (env_diff_opts) diff_opts = env_diff_opts;
  91
  92         done_preparing = 1;
  93         return external_diff_cmd;
  94 }
  95
  96 #define TEMPFILE_PATH_LEN               50
  97
  98 static struct diff_tempfile {
  99         const char *name; /* filename external diff should read from */
 100         char hex[41];
 101         char mode[10];
 102         char tmp_path[TEMPFILE_PATH_LEN];
 103 } diff_temp[2];
 104
 105 static int count_lines(const char *filename)
 106 {
 107         FILE *in;
 108         int count, ch, completely_empty = 1, nl_just_seen = 0;
 109         in = fopen(filename, "r");
 110         count = 0;
 111         while ((ch = fgetc(in)) != EOF)
 112                 if (ch == '\n') {
 113                         count++;
 114                         nl_just_seen = 1;
 115                         completely_empty = 0;
 116                 }
 117                 else {
 118                         nl_just_seen = 0;
 119                         completely_empty = 0;
 120                 }
 121         fclose(in);
 122         if (completely_empty)
 123                 return 0;
 124         if (!nl_just_seen)
 125                 count++; /* no trailing newline */
 126         return count;
 127 }
 128
 129 static void print_line_count(int count)
 130 {
 131         switch (count) {
 132         case 0:
 133                 printf("0,0");
 134                 break;
 135         case 1:
 136                 printf("1");
 137                 break;
 138         default:
 139                 printf("1,%d", count);
 140                 break;
 141         }
 142 }
 143
 144 static void copy_file(int prefix, const char *filename)
 145 {
 146         FILE *in;
 147         int ch, nl_just_seen = 1;
 148         in = fopen(filename, "r");
 149         while ((ch = fgetc(in)) != EOF) {
 150                 if (nl_just_seen)
 151                         putchar(prefix);
 152                 putchar(ch);
 153                 if (ch == '\n')
 154                         nl_just_seen = 1;
 155                 else
 156                         nl_just_seen = 0;
 157         }
 158         fclose(in);
 159         if (!nl_just_seen)
 160                 printf("\n\\ No newline at end of file\n");
 161 }
 162
 163 static void emit_rewrite_diff(const char *name_a,
 164                               const char *name_b,
 165                               struct diff_tempfile *temp)
 166 {
 167         /* Use temp[i].name as input, name_a and name_b as labels */
 168         int lc_a, lc_b;
 169         lc_a = count_lines(temp[0].name);
 170         lc_b = count_lines(temp[1].name);
 171         printf("--- %s\n+++ %s\n@@ -", name_a, name_b);
 172         print_line_count(lc_a);
 173         printf(" +");
 174         print_line_count(lc_b);
 175         printf(" @@\n");
 176         if (lc_a)
 177                 copy_file('-', temp[0].name);
 178         if (lc_b)
 179                 copy_file('+', temp[1].name);
 180 }
 181
 182 static int fill_mmfile(mmfile_t *mf, const char *file)
 183 {
 184         int fd = open(file, O_RDONLY);
 185         struct stat st;
 186         char *buf;
 187         unsigned long size;
 188
 189         mf->ptr = NULL;
 190         mf->size = 0;
 191         if (fd < 0)
 192                 return 0;
 193         fstat(fd, &st);
 194         size = st.st_size;
 195         buf = xmalloc(size);
 196         mf->ptr = buf;
 197         mf->size = size;
 198         while (size) {
 199                 int retval = read(fd, buf, size);
 200                 if (retval < 0) {
 201                         if (errno == EINTR || errno == EAGAIN)
 202                                 continue;
 203                         break;
 204                 }
 205                 if (!retval)
 206                         break;
 207                 buf += retval;
 208                 size -= retval;
 209         }
 210         mf->size -= size;
 211         close(fd);
 212         return 0;
 213 }
 214
 215 static int fn_out(void *priv, mmbuffer_t *mb, int nbuf)
 216 {
 217         int i;
 218
 219         for (i = 0; i < nbuf; i++)
 220                 if (!fwrite(mb[i].ptr, mb[i].size, 1, stdout))
 221                         return -1;
 222         return 0;
 223 }
 224
 225 static const char *builtin_diff(const char *name_a,
 226                          const char *name_b,
 227                          struct diff_tempfile *temp,
 228                          const char *xfrm_msg,
 229                          int complete_rewrite,
 230                          const char **args)
 231 {
 232         int i, next_at, cmd_size;
 233         mmfile_t mf1, mf2;
 234         const char *const diff_cmd = "diff -L%s -L%s";
 235         const char *const diff_arg  = "-- %s %s||:"; /* "||:" is to return 0 */
 236         const char *input_name_sq[2];
 237         const char *label_path[2];
 238         char *cmd;
 239
 240         /* diff_cmd and diff_arg have 4 %s in total which makes
 241          * the sum of these strings 8 bytes larger than required.
 242          * we use 2 spaces around diff-opts, and we need to count
 243          * terminating NUL; we used to subtract 5 here, but we do not
 244          * care about small leaks in this subprocess that is about
 245          * to exec "diff" anymore.
 246          */
 247         cmd_size = (strlen(diff_cmd) + strlen(diff_opts) + strlen(diff_arg)
 248                     + 128);
 249
 250         for (i = 0; i < 2; i++) {
 251                 input_name_sq[i] = sq_quote(temp[i].name);
 252                 if (!strcmp(temp[i].name, "/dev/null"))
 253                         label_path[i] = "/dev/null";
 254                 else if (!i)
 255                         label_path[i] = sq_quote(quote_two("a/", name_a));
 256                 else
 257                         label_path[i] = sq_quote(quote_two("b/", name_b));
 258                 cmd_size += (strlen(label_path[i]) + strlen(input_name_sq[i]));
 259         }
 260
 261         cmd = xmalloc(cmd_size);
 262
 263         next_at = 0;
 264         next_at += snprintf(cmd+next_at, cmd_size-next_at,
 265                             diff_cmd, label_path[0], label_path[1]);
 266         next_at += snprintf(cmd+next_at, cmd_size-next_at,
 267                             " %s ", diff_opts);
 268         next_at += snprintf(cmd+next_at, cmd_size-next_at,
 269                             diff_arg, input_name_sq[0], input_name_sq[1]);
 270
 271         printf("diff --git %s %s\n",
 272                quote_two("a/", name_a), quote_two("b/", name_b));
 273         if (label_path[0][0] == '/') {
 274                 /* dev/null */
 275                 printf("new file mode %s\n", temp[1].mode);
 276                 if (xfrm_msg && xfrm_msg[0])
 277                         puts(xfrm_msg);
 278         }
 279         else if (label_path[1][0] == '/') {
 280                 printf("deleted file mode %s\n", temp[0].mode);
 281                 if (xfrm_msg && xfrm_msg[0])
 282                         puts(xfrm_msg);
 283         }
 284         else {
 285                 if (strcmp(temp[0].mode, temp[1].mode)) {
 286                         printf("old mode %s\n", temp[0].mode);
 287                         printf("new mode %s\n", temp[1].mode);
 288                 }
 289                 if (xfrm_msg && xfrm_msg[0])
 290                         puts(xfrm_msg);
 291                 /*
 292                  * we do not run diff between different kind
 293                  * of objects.
 294                  */
 295                 if (strncmp(temp[0].mode, temp[1].mode, 3))
 296                         return NULL;
 297                 if (complete_rewrite) {
 298                         emit_rewrite_diff(name_a, name_b, temp);
 299                         return NULL;
 300                 }
 301         }
 302
 303         /* Un-quote the paths */
 304         if (label_path[0][0] != '/')
 305                 label_path[0] = quote_two("a/", name_a);
 306         if (label_path[1][0] != '/')
 307                 label_path[1] = quote_two("b/", name_b);
 308
 309         printf("--- %s\n", label_path[0]);
 310         printf("+++ %s\n", label_path[1]);
 311
 312         if (fill_mmfile(&mf1, temp[0].name) < 0 ||
 313             fill_mmfile(&mf2, temp[1].name) < 0)
 314                 die("unable to read files to diff");
 315
 316         /* Crazy xdl interfaces.. */
 317         {
 318                 xpparam_t xpp;
 319                 xdemitconf_t xecfg;
 320                 xdemitcb_t ecb;
 321
 322                 xpp.flags = XDF_NEED_MINIMAL;
 323                 xecfg.ctxlen = 3;
 324                 ecb.outf = fn_out;
 325                 xdl_diff(&mf1, &mf2, &xpp, &xecfg, &ecb);
 326         }
 327
 328         free(mf1.ptr);
 329         free(mf2.ptr);
 330         return NULL;
 331 }
 332
 333 struct diff_filespec *alloc_filespec(const char *path)
 334 {
 335         int namelen = strlen(path);
 336         struct diff_filespec *spec = xmalloc(sizeof(*spec) + namelen + 1);
 337
 338         memset(spec, 0, sizeof(*spec));
 339         spec->path = (char *)(spec + 1);
 340         memcpy(spec->path, path, namelen+1);
 341         return spec;
 342 }
 343
 344 void fill_filespec(struct diff_filespec *spec, const unsigned char *sha1,
 345                    unsigned short mode)
 346 {
 347         if (mode) {
 348                 spec->mode = DIFF_FILE_CANON_MODE(mode);
 349                 memcpy(spec->sha1, sha1, 20);
 350                 spec->sha1_valid = !!memcmp(sha1, null_sha1, 20);
 351         }
 352 }
 353
 354 /*
 355  * Given a name and sha1 pair, if the dircache tells us the file in
 356  * the work tree has that object contents, return true, so that
 357  * prepare_temp_file() does not have to inflate and extract.
 358  */
 359 static int work_tree_matches(const char *name, const unsigned char *sha1)
 360 {
 361         struct cache_entry *ce;
 362         struct stat st;
 363         int pos, len;
 364
 365         /* We do not read the cache ourselves here, because the
 366          * benchmark with my previous version that always reads cache
 367          * shows that it makes things worse for diff-tree comparing
 368          * two linux-2.6 kernel trees in an already checked out work
 369          * tree.  This is because most diff-tree comparisons deal with
 370          * only a small number of files, while reading the cache is
 371          * expensive for a large project, and its cost outweighs the
 372          * savings we get by not inflating the object to a temporary
 373          * file.  Practically, this code only helps when we are used
 374          * by diff-cache --cached, which does read the cache before
 375          * calling us.
 376          */
 377         if (!active_cache)
 378                 return 0;
 379
 380         len = strlen(name);
 381         pos = cache_name_pos(name, len);
 382         if (pos < 0)
 383                 return 0;
 384         ce = active_cache[pos];
 385         if ((lstat(name, &st) < 0) ||
 386             !S_ISREG(st.st_mode) || /* careful! */
 387             ce_match_stat(ce, &st, 0) ||
 388             memcmp(sha1, ce->sha1, 20))
 389                 return 0;
 390         /* we return 1 only when we can stat, it is a regular file,
 391          * stat information matches, and sha1 recorded in the cache
 392          * matches.  I.e. we know the file in the work tree really is
 393          * the same as the <name, sha1> pair.
 394          */
 395         return 1;
 396 }
 397
 398 static struct sha1_size_cache {
 399         unsigned char sha1[20];
 400         unsigned long size;
 401 } **sha1_size_cache;
 402 static int sha1_size_cache_nr, sha1_size_cache_alloc;
 403
 404 static struct sha1_size_cache *locate_size_cache(unsigned char *sha1,
 405                                                  int find_only,
 406                                                  unsigned long size)
 407 {
 408         int first, last;
 409         struct sha1_size_cache *e;
 410
 411         first = 0;
 412         last = sha1_size_cache_nr;
 413         while (last > first) {
 414                 int cmp, next = (last + first) >> 1;
 415                 e = sha1_size_cache[next];
 416                 cmp = memcmp(e->sha1, sha1, 20);
 417                 if (!cmp)
 418                         return e;
 419                 if (cmp < 0) {
 420                         last = next;
 421                         continue;
 422                 }
 423                 first = next+1;
 424         }
 425         /* not found */
 426         if (find_only)
 427                 return NULL;
 428         /* insert to make it at "first" */
 429         if (sha1_size_cache_alloc <= sha1_size_cache_nr) {
 430                 sha1_size_cache_alloc = alloc_nr(sha1_size_cache_alloc);
 431                 sha1_size_cache = xrealloc(sha1_size_cache,
 432                                            sha1_size_cache_alloc *
 433                                            sizeof(*sha1_size_cache));
 434         }
 435         sha1_size_cache_nr++;
 436         if (first < sha1_size_cache_nr)
 437                 memmove(sha1_size_cache + first + 1, sha1_size_cache + first,
 438                         (sha1_size_cache_nr - first - 1) *
 439                         sizeof(*sha1_size_cache));
 440         e = xmalloc(sizeof(struct sha1_size_cache));
 441         sha1_size_cache[first] = e;
 442         memcpy(e->sha1, sha1, 20);
 443         e->size = size;
 444         return e;
 445 }
 446
 447 /*
 448  * While doing rename detection and pickaxe operation, we may need to
 449  * grab the data for the blob (or file) for our own in-core comparison.
 450  * diff_filespec has data and size fields for this purpose.
 451  */
 452 int diff_populate_filespec(struct diff_filespec *s, int size_only)
 453 {
 454         int err = 0;
 455         if (!DIFF_FILE_VALID(s))
 456                 die("internal error: asking to populate invalid file.");
 457         if (S_ISDIR(s->mode))
 458                 return -1;
 459
 460         if (!use_size_cache)
 461                 size_only = 0;
 462
 463         if (s->data)
 464                 return err;
 465         if (!s->sha1_valid ||
 466             work_tree_matches(s->path, s->sha1)) {
 467                 struct stat st;
 468                 int fd;
 469                 if (lstat(s->path, &st) < 0) {
 470                         if (errno == ENOENT) {
 471                         err_empty:
 472                                 err = -1;
 473                         empty:
 474                                 s->data = "";
 475                                 s->size = 0;
 476                                 return err;
 477                         }
 478                 }
 479                 s->size = st.st_size;
 480                 if (!s->size)
 481                         goto empty;
 482                 if (size_only)
 483                         return 0;
 484                 if (S_ISLNK(st.st_mode)) {
 485                         int ret;
 486                         s->data = xmalloc(s->size);
 487                         s->should_free = 1;
 488                         ret = readlink(s->path, s->data, s->size);
 489                         if (ret < 0) {
 490                                 free(s->data);
 491                                 goto err_empty;
 492                         }
 493                         return 0;
 494                 }
 495                 fd = open(s->path, O_RDONLY);
 496                 if (fd < 0)
 497                         goto err_empty;
 498                 s->data = mmap(NULL, s->size, PROT_READ, MAP_PRIVATE, fd, 0);
 499                 close(fd);
 500                 if (s->data == MAP_FAILED)
 501                         goto err_empty;
 502                 s->should_munmap = 1;
 503         }
 504         else {
 505                 char type[20];
 506                 struct sha1_size_cache *e;
 507
 508                 if (size_only) {
 509                         e = locate_size_cache(s->sha1, 1, 0);
 510                         if (e) {
 511                                 s->size = e->size;
 512                                 return 0;
 513                         }
 514                         if (!sha1_object_info(s->sha1, type, &s->size))
 515                                 locate_size_cache(s->sha1, 0, s->size);
 516                 }
 517                 else {
 518                         s->data = read_sha1_file(s->sha1, type, &s->size);
 519                         s->should_free = 1;
 520                 }
 521         }
 522         return 0;
 523 }
 524
 525 void diff_free_filespec_data(struct diff_filespec *s)
 526 {
 527         if (s->should_free)
 528                 free(s->data);
 529         else if (s->should_munmap)
 530                 munmap(s->data, s->size);
 531         s->should_free = s->should_munmap = 0;
 532         s->data = NULL;
 533 }
 534
 535 static void prep_temp_blob(struct diff_tempfile *temp,
 536                            void *blob,
 537                            unsigned long size,
 538                            const unsigned char *sha1,
 539                            int mode)
 540 {
 541         int fd;
 542
 543         fd = git_mkstemp(temp->tmp_path, TEMPFILE_PATH_LEN, ".diff_XXXXXX");
 544         if (fd < 0)
 545                 die("unable to create temp-file");
 546         if (write(fd, blob, size) != size)
 547                 die("unable to write temp-file");
 548         close(fd);
 549         temp->name = temp->tmp_path;
 550         strcpy(temp->hex, sha1_to_hex(sha1));
 551         temp->hex[40] = 0;
 552         sprintf(temp->mode, "%06o", mode);
 553 }
 554
 555 static void prepare_temp_file(const char *name,
 556                               struct diff_tempfile *temp,
 557                               struct diff_filespec *one)
 558 {
 559         if (!DIFF_FILE_VALID(one)) {
 560         not_a_valid_file:
 561                 /* A '-' entry produces this for file-2, and
 562                  * a '+' entry produces this for file-1.
 563                  */
 564                 temp->name = "/dev/null";
 565                 strcpy(temp->hex, ".");
 566                 strcpy(temp->mode, ".");
 567                 return;
 568         }
 569
 570         if (!one->sha1_valid ||
 571             work_tree_matches(name, one->sha1)) {
 572                 struct stat st;
 573                 if (lstat(name, &st) < 0) {
 574                         if (errno == ENOENT)
 575                                 goto not_a_valid_file;
 576                         die("stat(%s): %s", name, strerror(errno));
 577                 }
 578                 if (S_ISLNK(st.st_mode)) {
 579                         int ret;
 580                         char buf[PATH_MAX + 1]; /* ought to be SYMLINK_MAX */
 581                         if (sizeof(buf) <= st.st_size)
 582                                 die("symlink too long: %s", name);
 583                         ret = readlink(name, buf, st.st_size);
 584                         if (ret < 0)
 585                                 die("readlink(%s)", name);
 586                         prep_temp_blob(temp, buf, st.st_size,
 587                                        (one->sha1_valid ?
 588                                         one->sha1 : null_sha1),
 589                                        (one->sha1_valid ?
 590                                         one->mode : S_IFLNK));
 591                 }
 592                 else {
 593                         /* we can borrow from the file in the work tree */
 594                         temp->name = name;
 595                         if (!one->sha1_valid)
 596                                 strcpy(temp->hex, sha1_to_hex(null_sha1));
 597                         else
 598                                 strcpy(temp->hex, sha1_to_hex(one->sha1));
 599                         /* Even though we may sometimes borrow the
 600                          * contents from the work tree, we always want
 601                          * one->mode.  mode is trustworthy even when
 602                          * !(one->sha1_valid), as long as
 603                          * DIFF_FILE_VALID(one).
 604                          */
 605                         sprintf(temp->mode, "%06o", one->mode);
 606                 }
 607                 return;
 608         }
 609         else {
 610                 if (diff_populate_filespec(one, 0))
 611                         die("cannot read data blob for %s", one->path);
 612                 prep_temp_blob(temp, one->data, one->size,
 613                                one->sha1, one->mode);
 614         }
 615 }
 616
 617 static void remove_tempfile(void)
 618 {
 619         int i;
 620
 621         for (i = 0; i < 2; i++)
 622                 if (diff_temp[i].name == diff_temp[i].tmp_path) {
 623                         unlink(diff_temp[i].name);
 624                         diff_temp[i].name = NULL;
 625                 }
 626 }
 627
 628 static void remove_tempfile_on_signal(int signo)
 629 {
 630         remove_tempfile();
 631         signal(SIGINT, SIG_DFL);
 632         raise(signo);
 633 }
 634
 635 static int spawn_prog(const char *pgm, const char **arg)
 636 {
 637         pid_t pid;
 638         int status;
 639
 640         fflush(NULL);
 641         pid = fork();
 642         if (pid < 0)
 643                 die("unable to fork");
 644         if (!pid) {
 645                 execvp(pgm, (char *const*) arg);
 646                 exit(255);
 647         }
 648
 649         while (waitpid(pid, &status, 0) < 0) {
 650                 if (errno == EINTR)
 651                         continue;
 652                 return -1;
 653         }
 654
 655         /* Earlier we did not check the exit status because
 656          * diff exits non-zero if files are different, and
 657          * we are not interested in knowing that.  It was a
 658          * mistake which made it harder to quit a diff-*
 659          * session that uses the git-apply-patch-script as
 660          * the GIT_EXTERNAL_DIFF.  A custom GIT_EXTERNAL_DIFF
 661          * should also exit non-zero only when it wants to
 662          * abort the entire diff-* session.
 663          */
 664         if (WIFEXITED(status) && !WEXITSTATUS(status))
 665                 return 0;
 666         return -1;
 667 }
 668
 669 /* An external diff command takes:
 670  *
 671  * diff-cmd name infile1 infile1-sha1 infile1-mode \
 672  *               infile2 infile2-sha1 infile2-mode [ rename-to ]
 673  *
 674  */
 675 static void run_external_diff(const char *pgm,
 676                               const char *name,
 677                               const char *other,
 678                               struct diff_filespec *one,
 679                               struct diff_filespec *two,
 680                               const char *xfrm_msg,
 681                               int complete_rewrite)
 682 {
 683         const char *spawn_arg[10];
 684         struct diff_tempfile *temp = diff_temp;
 685         int retval;
 686         static int atexit_asked = 0;
 687         const char *othername;
 688
 689         othername = (other? other : name);
 690         if (one && two) {
 691                 prepare_temp_file(name, &temp[0], one);
 692                 prepare_temp_file(othername, &temp[1], two);
 693                 if (! atexit_asked &&
 694                     (temp[0].name == temp[0].tmp_path ||
 695                      temp[1].name == temp[1].tmp_path)) {
 696                         atexit_asked = 1;
 697                         atexit(remove_tempfile);
 698                 }
 699                 signal(SIGINT, remove_tempfile_on_signal);
 700         }
 701
 702         if (pgm) {
 703                 const char **arg = &spawn_arg[0];
 704                 if (one && two) {
 705                         *arg++ = pgm;
 706                         *arg++ = name;
 707                         *arg++ = temp[0].name;
 708                         *arg++ = temp[0].hex;
 709                         *arg++ = temp[0].mode;
 710                         *arg++ = temp[1].name;
 711                         *arg++ = temp[1].hex;
 712                         *arg++ = temp[1].mode;
 713                         if (other) {
 714                                 *arg++ = other;
 715                                 *arg++ = xfrm_msg;
 716                         }
 717                 } else {
 718                         *arg++ = pgm;
 719                         *arg++ = name;
 720                 }
 721                 *arg = NULL;
 722         } else {
 723                 if (one && two) {
 724                         pgm = builtin_diff(name, othername, temp, xfrm_msg, complete_rewrite, spawn_arg);
 725                 } else
 726                         printf("* Unmerged path %s\n", name);
 727         }
 728
 729         retval = 0;
 730         if (pgm)
 731                 retval = spawn_prog(pgm, spawn_arg);
 732         remove_tempfile();
 733         if (retval) {
 734                 fprintf(stderr, "external diff died, stopping at %s.\n", name);
 735                 exit(1);
 736         }
 737 }
 738
 739 static void diff_fill_sha1_info(struct diff_filespec *one)
 740 {
 741         if (DIFF_FILE_VALID(one)) {
 742                 if (!one->sha1_valid) {
 743                         struct stat st;
 744                         if (lstat(one->path, &st) < 0)
 745                                 die("stat %s", one->path);
 746                         if (index_path(one->sha1, one->path, &st, 0))
 747                                 die("cannot hash %s\n", one->path);
 748                 }
 749         }
 750         else
 751                 memset(one->sha1, 0, 20);
 752 }
 753
 754 static void run_diff(struct diff_filepair *p, struct diff_options *o)
 755 {
 756         const char *pgm = external_diff();
 757         char msg[PATH_MAX*2+300], *xfrm_msg;
 758         struct diff_filespec *one;
 759         struct diff_filespec *two;
 760         const char *name;
 761         const char *other;
 762         char *name_munged, *other_munged;
 763         int complete_rewrite = 0;
 764         int len;
 765
 766         if (DIFF_PAIR_UNMERGED(p)) {
 767                 /* unmerged */
 768                 run_external_diff(pgm, p->one->path, NULL, NULL, NULL, NULL,
 769                                   0);
 770                 return;
 771         }
 772
 773         name = p->one->path;
 774         other = (strcmp(name, p->two->path) ? p->two->path : NULL);
 775         name_munged = quote_one(name);
 776         other_munged = quote_one(other);
 777         one = p->one; two = p->two;
 778
 779         diff_fill_sha1_info(one);
 780         diff_fill_sha1_info(two);
 781
 782         len = 0;
 783         switch (p->status) {
 784         case DIFF_STATUS_COPIED:
 785                 len += snprintf(msg + len, sizeof(msg) - len,
 786                                 "similarity index %d%%\n"
 787                                 "copy from %s\n"
 788                                 "copy to %s\n",
 789                                 (int)(0.5 + p->score * 100.0/MAX_SCORE),
 790                                 name_munged, other_munged);
 791                 break;
 792         case DIFF_STATUS_RENAMED:
 793                 len += snprintf(msg + len, sizeof(msg) - len,
 794                                 "similarity index %d%%\n"
 795                                 "rename from %s\n"
 796                                 "rename to %s\n",
 797                                 (int)(0.5 + p->score * 100.0/MAX_SCORE),
 798                                 name_munged, other_munged);
 799                 break;
 800         case DIFF_STATUS_MODIFIED:
 801                 if (p->score) {
 802                         len += snprintf(msg + len, sizeof(msg) - len,
 803                                         "dissimilarity index %d%%\n",
 804                                         (int)(0.5 + p->score *
 805                                               100.0/MAX_SCORE));
 806                         complete_rewrite = 1;
 807                         break;
 808                 }
 809                 /* fallthru */
 810         default:
 811                 /* nothing */
 812                 ;
 813         }
 814
 815         if (memcmp(one->sha1, two->sha1, 20)) {
 816                 char one_sha1[41];
 817                 int abbrev = o->full_index ? 40 : DEFAULT_ABBREV;
 818                 memcpy(one_sha1, sha1_to_hex(one->sha1), 41);
 819
 820                 len += snprintf(msg + len, sizeof(msg) - len,
 821                                 "index %.*s..%.*s",
 822                                 abbrev, one_sha1, abbrev,
 823                                 sha1_to_hex(two->sha1));
 824                 if (one->mode == two->mode)
 825                         len += snprintf(msg + len, sizeof(msg) - len,
 826                                         " %06o", one->mode);
 827                 len += snprintf(msg + len, sizeof(msg) - len, "\n");
 828         }
 829
 830         if (len)
 831                 msg[--len] = 0;
 832         xfrm_msg = len ? msg : NULL;
 833
 834         if (!pgm &&
 835             DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) &&
 836             (S_IFMT & one->mode) != (S_IFMT & two->mode)) {
 837                 /* a filepair that changes between file and symlink
 838                  * needs to be split into deletion and creation.
 839                  */
 840                 struct diff_filespec *null = alloc_filespec(two->path);
 841                 run_external_diff(NULL, name, other, one, null, xfrm_msg, 0);
 842                 free(null);
 843                 null = alloc_filespec(one->path);
 844                 run_external_diff(NULL, name, other, null, two, xfrm_msg, 0);
 845                 free(null);
 846         }
 847         else
 848                 run_external_diff(pgm, name, other, one, two, xfrm_msg,
 849                                   complete_rewrite);
 850
 851         free(name_munged);
 852         free(other_munged);
 853 }
 854
 855 void diff_setup(struct diff_options *options)
 856 {
 857         memset(options, 0, sizeof(*options));
 858         options->output_format = DIFF_FORMAT_RAW;
 859         options->line_termination = '\n';
 860         options->break_opt = -1;
 861         options->rename_limit = -1;
 862
 863         options->change = diff_change;
 864         options->add_remove = diff_addremove;
 865 }
 866
 867 int diff_setup_done(struct diff_options *options)
 868 {
 869         if ((options->find_copies_harder &&
 870              options->detect_rename != DIFF_DETECT_COPY) ||
 871             (0 <= options->rename_limit && !options->detect_rename))
 872                 return -1;
 873         if (options->detect_rename && options->rename_limit < 0)
 874                 options->rename_limit = diff_rename_limit_default;
 875         if (options->setup & DIFF_SETUP_USE_CACHE) {
 876                 if (!active_cache)
 877                         /* read-cache does not die even when it fails
 878                          * so it is safe for us to do this here.  Also
 879                          * it does not smudge active_cache or active_nr
 880                          * when it fails, so we do not have to worry about
 881                          * cleaning it up ourselves either.
 882                          */
 883                         read_cache();
 884         }
 885         if (options->setup & DIFF_SETUP_USE_SIZE_CACHE)
 886                 use_size_cache = 1;
 887         if (options->abbrev <= 0 || 40 < options->abbrev)
 888                 options->abbrev = 40; /* full */
 889
 890         return 0;
 891 }
 892
 893 int diff_opt_parse(struct diff_options *options, const char **av, int ac)
 894 {
 895         const char *arg = av[0];
 896         if (!strcmp(arg, "-p") || !strcmp(arg, "-u"))
 897                 options->output_format = DIFF_FORMAT_PATCH;
 898         else if (!strcmp(arg, "-z"))
 899                 options->line_termination = 0;
 900         else if (!strncmp(arg, "-l", 2))
 901                 options->rename_limit = strtoul(arg+2, NULL, 10);
 902         else if (!strcmp(arg, "--full-index"))
 903                 options->full_index = 1;
 904         else if (!strcmp(arg, "--name-only"))
 905                 options->output_format = DIFF_FORMAT_NAME;
 906         else if (!strcmp(arg, "--name-status"))
 907                 options->output_format = DIFF_FORMAT_NAME_STATUS;
 908         else if (!strcmp(arg, "-R"))
 909                 options->reverse_diff = 1;
 910         else if (!strncmp(arg, "-S", 2))
 911                 options->pickaxe = arg + 2;
 912         else if (!strcmp(arg, "-s"))
 913                 options->output_format = DIFF_FORMAT_NO_OUTPUT;
 914         else if (!strncmp(arg, "-O", 2))
 915                 options->orderfile = arg + 2;
 916         else if (!strncmp(arg, "--diff-filter=", 14))
 917                 options->filter = arg + 14;
 918         else if (!strcmp(arg, "--pickaxe-all"))
 919                 options->pickaxe_opts = DIFF_PICKAXE_ALL;
 920         else if (!strncmp(arg, "-B", 2)) {
 921                 if ((options->break_opt =
 922                      diff_scoreopt_parse(arg)) == -1)
 923                         return -1;
 924         }
 925         else if (!strncmp(arg, "-M", 2)) {
 926                 if ((options->rename_score =
 927                      diff_scoreopt_parse(arg)) == -1)
 928                         return -1;
 929                 options->detect_rename = DIFF_DETECT_RENAME;
 930         }
 931         else if (!strncmp(arg, "-C", 2)) {
 932                 if ((options->rename_score =
 933                      diff_scoreopt_parse(arg)) == -1)
 934                         return -1;
 935                 options->detect_rename = DIFF_DETECT_COPY;
 936         }
 937         else if (!strcmp(arg, "--find-copies-harder"))
 938                 options->find_copies_harder = 1;
 939         else if (!strcmp(arg, "--abbrev"))
 940                 options->abbrev = DEFAULT_ABBREV;
 941         else if (!strncmp(arg, "--abbrev=", 9)) {
 942                 options->abbrev = strtoul(arg + 9, NULL, 10);
 943                 if (options->abbrev < MINIMUM_ABBREV)
 944                         options->abbrev = MINIMUM_ABBREV;
 945                 else if (40 < options->abbrev)
 946                         options->abbrev = 40;
 947         }
 948         else
 949                 return 0;
 950         return 1;
 951 }
 952
 953 static int parse_num(const char **cp_p)
 954 {
 955         unsigned long num, scale;
 956         int ch, dot;
 957         const char *cp = *cp_p;
 958
 959         num = 0;
 960         scale = 1;
 961         dot = 0;
 962         for(;;) {
 963                 ch = *cp;
 964                 if ( !dot && ch == '.' ) {
 965                         scale = 1;
 966                         dot = 1;
 967                 } else if ( ch == '%' ) {
 968                         scale = dot ? scale*100 : 100;
 969                         cp++;   /* % is always at the end */
 970                         break;
 971                 } else if ( ch >= '0' && ch <= '9' ) {
 972                         if ( scale < 100000 ) {
 973                                 scale *= 10;
 974                                 num = (num*10) + (ch-'0');
 975                         }
 976                 } else {
 977                         break;
 978                 }
 979                 cp++;
 980         }
 981         *cp_p = cp;
 982
 983         /* user says num divided by scale and we say internally that
 984          * is MAX_SCORE * num / scale.
 985          */
 986         return (num >= scale) ? MAX_SCORE : (MAX_SCORE * num / scale);
 987 }
 988
 989 int diff_scoreopt_parse(const char *opt)
 990 {
 991         int opt1, opt2, cmd;
 992
 993         if (*opt++ != '-')
 994                 return -1;
 995         cmd = *opt++;
 996         if (cmd != 'M' && cmd != 'C' && cmd != 'B')
 997                 return -1; /* that is not a -M, -C nor -B option */
 998
 999         opt1 = parse_num(&opt);
1000         if (cmd != 'B')
1001                 opt2 = 0;
1002         else {
1003                 if (*opt == 0)
1004                         opt2 = 0;
1005                 else if (*opt != '/')
1006                         return -1; /* we expect -B80/99 or -B80 */
1007                 else {
1008                         opt++;
1009                         opt2 = parse_num(&opt);
1010                 }
1011         }
1012         if (*opt != 0)
1013                 return -1;
1014         return opt1 | (opt2 << 16);
1015 }
1016
1017 struct diff_queue_struct diff_queued_diff;
1018
1019 void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp)
1020 {
1021         if (queue->alloc <= queue->nr) {
1022                 queue->alloc = alloc_nr(queue->alloc);
1023                 queue->queue = xrealloc(queue->queue,
1024                                         sizeof(dp) * queue->alloc);
1025         }
1026         queue->queue[queue->nr++] = dp;
1027 }
1028
1029 struct diff_filepair *diff_queue(struct diff_queue_struct *queue,
1030                                  struct diff_filespec *one,
1031                                  struct diff_filespec *two)
1032 {
1033         struct diff_filepair *dp = xmalloc(sizeof(*dp));
1034         dp->one = one;
1035         dp->two = two;
1036         dp->score = 0;
1037         dp->status = 0;
1038         dp->source_stays = 0;
1039         dp->broken_pair = 0;
1040         if (queue)
1041                 diff_q(queue, dp);
1042         return dp;
1043 }
1044
1045 void diff_free_filepair(struct diff_filepair *p)
1046 {
1047         diff_free_filespec_data(p->one);
1048         diff_free_filespec_data(p->two);
1049         free(p->one);
1050         free(p->two);
1051         free(p);
1052 }
1053
1054 /* This is different from find_unique_abbrev() in that
1055  * it stuffs the result with dots for alignment.
1056  */
1057 const char *diff_unique_abbrev(const unsigned char *sha1, int len)
1058 {
1059         int abblen;
1060         const char *abbrev;
1061         if (len == 40)
1062                 return sha1_to_hex(sha1);
1063
1064         abbrev = find_unique_abbrev(sha1, len);
1065         if (!abbrev)
1066                 return sha1_to_hex(sha1);
1067         abblen = strlen(abbrev);
1068         if (abblen < 37) {
1069                 static char hex[41];
1070                 if (len < abblen && abblen <= len + 2)
1071                         sprintf(hex, "%s%.*s", abbrev, len+3-abblen, "..");
1072                 else
1073                         sprintf(hex, "%s...", abbrev);
1074                 return hex;
1075         }
1076         return sha1_to_hex(sha1);
1077 }
1078
1079 static void diff_flush_raw(struct diff_filepair *p,
1080                            int line_termination,
1081                            int inter_name_termination,
1082                            struct diff_options *options)
1083 {
1084         int two_paths;
1085         char status[10];
1086         int abbrev = options->abbrev;
1087         const char *path_one, *path_two;
1088         int output_format = options->output_format;
1089
1090         path_one = p->one->path;
1091         path_two = p->two->path;
1092         if (line_termination) {
1093                 path_one = quote_one(path_one);
1094                 path_two = quote_one(path_two);
1095         }
1096
1097         if (p->score)
1098                 sprintf(status, "%c%03d", p->status,
1099                         (int)(0.5 + p->score * 100.0/MAX_SCORE));
1100         else {
1101                 status[0] = p->status;
1102                 status[1] = 0;
1103         }
1104         switch (p->status) {
1105         case DIFF_STATUS_COPIED:
1106         case DIFF_STATUS_RENAMED:
1107                 two_paths = 1;
1108                 break;
1109         case DIFF_STATUS_ADDED:
1110         case DIFF_STATUS_DELETED:
1111                 two_paths = 0;
1112                 break;
1113         default:
1114                 two_paths = 0;
1115                 break;
1116         }
1117         if (output_format != DIFF_FORMAT_NAME_STATUS) {
1118                 printf(":%06o %06o %s ",
1119                        p->one->mode, p->two->mode,
1120                        diff_unique_abbrev(p->one->sha1, abbrev));
1121                 printf("%s ",
1122                        diff_unique_abbrev(p->two->sha1, abbrev));
1123         }
1124         printf("%s%c%s", status, inter_name_termination, path_one);
1125         if (two_paths)
1126                 printf("%c%s", inter_name_termination, path_two);
1127         putchar(line_termination);
1128         if (path_one != p->one->path)
1129                 free((void*)path_one);
1130         if (path_two != p->two->path)
1131                 free((void*)path_two);
1132 }
1133
1134 static void diff_flush_name(struct diff_filepair *p,
1135                             int inter_name_termination,
1136                             int line_termination)
1137 {
1138         char *path = p->two->path;
1139
1140         if (line_termination)
1141                 path = quote_one(p->two->path);
1142         else
1143                 path = p->two->path;
1144         printf("%s%c", path, line_termination);
1145         if (p->two->path != path)
1146                 free(path);
1147 }
1148
1149 int diff_unmodified_pair(struct diff_filepair *p)
1150 {
1151         /* This function is written stricter than necessary to support
1152          * the currently implemented transformers, but the idea is to
1153          * let transformers to produce diff_filepairs any way they want,
1154          * and filter and clean them up here before producing the output.
1155          */
1156         struct diff_filespec *one, *two;
1157
1158         if (DIFF_PAIR_UNMERGED(p))
1159                 return 0; /* unmerged is interesting */
1160
1161         one = p->one;
1162         two = p->two;
1163
1164         /* deletion, addition, mode or type change
1165          * and rename are all interesting.
1166          */
1167         if (DIFF_FILE_VALID(one) != DIFF_FILE_VALID(two) ||
1168             DIFF_PAIR_MODE_CHANGED(p) ||
1169             strcmp(one->path, two->path))
1170                 return 0;
1171
1172         /* both are valid and point at the same path.  that is, we are
1173          * dealing with a change.
1174          */
1175         if (one->sha1_valid && two->sha1_valid &&
1176             !memcmp(one->sha1, two->sha1, sizeof(one->sha1)))
1177                 return 1; /* no change */
1178         if (!one->sha1_valid && !two->sha1_valid)
1179                 return 1; /* both look at the same file on the filesystem. */
1180         return 0;
1181 }
1182
1183 static void diff_flush_patch(struct diff_filepair *p, struct diff_options *o)
1184 {
1185         if (diff_unmodified_pair(p))
1186                 return;
1187
1188         if ((DIFF_FILE_VALID(p->one) && S_ISDIR(p->one->mode)) ||
1189             (DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
1190                 return; /* no tree diffs in patch format */
1191
1192         run_diff(p, o);
1193 }
1194
1195 int diff_queue_is_empty(void)
1196 {
1197         struct diff_queue_struct *q = &diff_queued_diff;
1198         int i;
1199         for (i = 0; i < q->nr; i++)
1200                 if (!diff_unmodified_pair(q->queue[i]))
1201                         return 0;
1202         return 1;
1203 }
1204
1205 #if DIFF_DEBUG
1206 void diff_debug_filespec(struct diff_filespec *s, int x, const char *one)
1207 {
1208         fprintf(stderr, "queue[%d] %s (%s) %s %06o %s\n",
1209                 x, one ? one : "",
1210                 s->path,
1211                 DIFF_FILE_VALID(s) ? "valid" : "invalid",
1212                 s->mode,
1213                 s->sha1_valid ? sha1_to_hex(s->sha1) : "");
1214         fprintf(stderr, "queue[%d] %s size %lu flags %d\n",
1215                 x, one ? one : "",
1216                 s->size, s->xfrm_flags);
1217 }
1218
1219 void diff_debug_filepair(const struct diff_filepair *p, int i)
1220 {
1221         diff_debug_filespec(p->one, i, "one");
1222         diff_debug_filespec(p->two, i, "two");
1223         fprintf(stderr, "score %d, status %c stays %d broken %d\n",
1224                 p->score, p->status ? p->status : '?',
1225                 p->source_stays, p->broken_pair);
1226 }
1227
1228 void diff_debug_queue(const char *msg, struct diff_queue_struct *q)
1229 {
1230         int i;
1231         if (msg)
1232                 fprintf(stderr, "%s\n", msg);
1233         fprintf(stderr, "q->nr = %d\n", q->nr);
1234         for (i = 0; i < q->nr; i++) {
1235                 struct diff_filepair *p = q->queue[i];
1236                 diff_debug_filepair(p, i);
1237         }
1238 }
1239 #endif
1240
1241 static void diff_resolve_rename_copy(void)
1242 {
1243         int i, j;
1244         struct diff_filepair *p, *pp;
1245         struct diff_queue_struct *q = &diff_queued_diff;
1246
1247         diff_debug_queue("resolve-rename-copy", q);
1248
1249         for (i = 0; i < q->nr; i++) {
1250                 p = q->queue[i];
1251                 p->status = 0; /* undecided */
1252                 if (DIFF_PAIR_UNMERGED(p))
1253                         p->status = DIFF_STATUS_UNMERGED;
1254                 else if (!DIFF_FILE_VALID(p->one))
1255                         p->status = DIFF_STATUS_ADDED;
1256                 else if (!DIFF_FILE_VALID(p->two))
1257                         p->status = DIFF_STATUS_DELETED;
1258                 else if (DIFF_PAIR_TYPE_CHANGED(p))
1259                         p->status = DIFF_STATUS_TYPE_CHANGED;
1260
1261                 /* from this point on, we are dealing with a pair
1262                  * whose both sides are valid and of the same type, i.e.
1263                  * either in-place edit or rename/copy edit.
1264                  */
1265                 else if (DIFF_PAIR_RENAME(p)) {
1266                         if (p->source_stays) {
1267                                 p->status = DIFF_STATUS_COPIED;
1268                                 continue;
1269                         }
1270                         /* See if there is some other filepair that
1271                          * copies from the same source as us.  If so
1272                          * we are a copy.  Otherwise we are either a
1273                          * copy if the path stays, or a rename if it
1274                          * does not, but we already handled "stays" case.
1275                          */
1276                         for (j = i + 1; j < q->nr; j++) {
1277                                 pp = q->queue[j];
1278                                 if (strcmp(pp->one->path, p->one->path))
1279                                         continue; /* not us */
1280                                 if (!DIFF_PAIR_RENAME(pp))
1281                                         continue; /* not a rename/copy */
1282                                 /* pp is a rename/copy from the same source */
1283                                 p->status = DIFF_STATUS_COPIED;
1284                                 break;
1285                         }
1286                         if (!p->status)
1287                                 p->status = DIFF_STATUS_RENAMED;
1288                 }
1289                 else if (memcmp(p->one->sha1, p->two->sha1, 20) ||
1290                          p->one->mode != p->two->mode)
1291                         p->status = DIFF_STATUS_MODIFIED;
1292                 else {
1293                         /* This is a "no-change" entry and should not
1294                          * happen anymore, but prepare for broken callers.
1295                          */
1296                         error("feeding unmodified %s to diffcore",
1297                               p->one->path);
1298                         p->status = DIFF_STATUS_UNKNOWN;
1299                 }
1300         }
1301         diff_debug_queue("resolve-rename-copy done", q);
1302 }
1303
1304 void diff_flush(struct diff_options *options)
1305 {
1306         struct diff_queue_struct *q = &diff_queued_diff;
1307         int i;
1308         int inter_name_termination = '\t';
1309         int diff_output_format = options->output_format;
1310         int line_termination = options->line_termination;
1311
1312         if (!line_termination)
1313                 inter_name_termination = 0;
1314
1315         for (i = 0; i < q->nr; i++) {
1316                 struct diff_filepair *p = q->queue[i];
1317                 if ((diff_output_format == DIFF_FORMAT_NO_OUTPUT) ||
1318                     (p->status == DIFF_STATUS_UNKNOWN))
1319                         continue;
1320                 if (p->status == 0)
1321                         die("internal error in diff-resolve-rename-copy");
1322                 switch (diff_output_format) {
1323                 case DIFF_FORMAT_PATCH:
1324                         diff_flush_patch(p, options);
1325                         break;
1326                 case DIFF_FORMAT_RAW:
1327                 case DIFF_FORMAT_NAME_STATUS:
1328                         diff_flush_raw(p, line_termination,
1329                                        inter_name_termination,
1330                                        options);
1331                         break;
1332                 case DIFF_FORMAT_NAME:
1333                         diff_flush_name(p,
1334                                         inter_name_termination,
1335                                         line_termination);
1336                         break;
1337                 }
1338                 diff_free_filepair(q->queue[i]);
1339         }
1340         free(q->queue);
1341         q->queue = NULL;
1342         q->nr = q->alloc = 0;
1343 }
1344
1345 static void diffcore_apply_filter(const char *filter)
1346 {
1347         int i;
1348         struct diff_queue_struct *q = &diff_queued_diff;
1349         struct diff_queue_struct outq;
1350         outq.queue = NULL;
1351         outq.nr = outq.alloc = 0;
1352
1353         if (!filter)
1354                 return;
1355
1356         if (strchr(filter, DIFF_STATUS_FILTER_AON)) {
1357                 int found;
1358                 for (i = found = 0; !found && i < q->nr; i++) {
1359                         struct diff_filepair *p = q->queue[i];
1360                         if (((p->status == DIFF_STATUS_MODIFIED) &&
1361                              ((p->score &&
1362                                strchr(filter, DIFF_STATUS_FILTER_BROKEN)) ||
1363                               (!p->score &&
1364                                strchr(filter, DIFF_STATUS_MODIFIED)))) ||
1365                             ((p->status != DIFF_STATUS_MODIFIED) &&
1366                              strchr(filter, p->status)))
1367                                 found++;
1368                 }
1369                 if (found)
1370                         return;
1371
1372                 /* otherwise we will clear the whole queue
1373                  * by copying the empty outq at the end of this
1374                  * function, but first clear the current entries
1375                  * in the queue.
1376                  */
1377                 for (i = 0; i < q->nr; i++)
1378                         diff_free_filepair(q->queue[i]);
1379         }
1380         else {
1381                 /* Only the matching ones */
1382                 for (i = 0; i < q->nr; i++) {
1383                         struct diff_filepair *p = q->queue[i];
1384
1385                         if (((p->status == DIFF_STATUS_MODIFIED) &&
1386                              ((p->score &&
1387                                strchr(filter, DIFF_STATUS_FILTER_BROKEN)) ||
1388                               (!p->score &&
1389                                strchr(filter, DIFF_STATUS_MODIFIED)))) ||
1390                             ((p->status != DIFF_STATUS_MODIFIED) &&
1391                              strchr(filter, p->status)))
1392                                 diff_q(&outq, p);
1393                         else
1394                                 diff_free_filepair(p);
1395                 }
1396         }
1397         free(q->queue);
1398         *q = outq;
1399 }
1400
1401 void diffcore_std(struct diff_options *options)
1402 {
1403         if (options->paths && options->paths[0])
1404                 diffcore_pathspec(options->paths);
1405         if (options->break_opt != -1)
1406                 diffcore_break(options->break_opt);
1407         if (options->detect_rename)
1408                 diffcore_rename(options);
1409         if (options->break_opt != -1)
1410                 diffcore_merge_broken();
1411         if (options->pickaxe)
1412                 diffcore_pickaxe(options->pickaxe, options->pickaxe_opts);
1413         if (options->orderfile)
1414                 diffcore_order(options->orderfile);
1415         diff_resolve_rename_copy();
1416         diffcore_apply_filter(options->filter);
1417 }
1418
1419
1420 void diffcore_std_no_resolve(struct diff_options *options)
1421 {
1422         if (options->pickaxe)
1423                 diffcore_pickaxe(options->pickaxe, options->pickaxe_opts);
1424         if (options->orderfile)
1425                 diffcore_order(options->orderfile);
1426         diffcore_apply_filter(options->filter);
1427 }
1428
1429 void diff_addremove(struct diff_options *options,
1430                     int addremove, unsigned mode,
1431                     const unsigned char *sha1,
1432                     const char *base, const char *path)
1433 {
1434         char concatpath[PATH_MAX];
1435         struct diff_filespec *one, *two;
1436
1437         /* This may look odd, but it is a preparation for
1438          * feeding "there are unchanged files which should
1439          * not produce diffs, but when you are doing copy
1440          * detection you would need them, so here they are"
1441          * entries to the diff-core.  They will be prefixed
1442          * with something like '=' or '*' (I haven't decided
1443          * which but should not make any difference).
1444          * Feeding the same new and old to diff_change()
1445          * also has the same effect.
1446          * Before the final output happens, they are pruned after
1447          * merged into rename/copy pairs as appropriate.
1448          */
1449         if (options->reverse_diff)
1450                 addremove = (addremove == '+' ? '-' :
1451                              addremove == '-' ? '+' : addremove);
1452
1453         if (!path) path = "";
1454         sprintf(concatpath, "%s%s", base, path);
1455         one = alloc_filespec(concatpath);
1456         two = alloc_filespec(concatpath);
1457
1458         if (addremove != '+')
1459                 fill_filespec(one, sha1, mode);
1460         if (addremove != '-')
1461                 fill_filespec(two, sha1, mode);
1462
1463         diff_queue(&diff_queued_diff, one, two);
1464 }
1465
1466 void diff_change(struct diff_options *options,
1467                  unsigned old_mode, unsigned new_mode,
1468                  const unsigned char *old_sha1,
1469                  const unsigned char *new_sha1,
1470                  const char *base, const char *path)
1471 {
1472         char concatpath[PATH_MAX];
1473         struct diff_filespec *one, *two;
1474
1475         if (options->reverse_diff) {
1476                 unsigned tmp;
1477                 const unsigned char *tmp_c;
1478                 tmp = old_mode; old_mode = new_mode; new_mode = tmp;
1479                 tmp_c = old_sha1; old_sha1 = new_sha1; new_sha1 = tmp_c;
1480         }
1481         if (!path) path = "";
1482         sprintf(concatpath, "%s%s", base, path);
1483         one = alloc_filespec(concatpath);
1484         two = alloc_filespec(concatpath);
1485         fill_filespec(one, old_sha1, old_mode);
1486         fill_filespec(two, new_sha1, new_mode);
1487
1488         diff_queue(&diff_queued_diff, one, two);
1489 }
1490
1491 void diff_unmerge(struct diff_options *options,
1492                   const char *path)
1493 {
1494         struct diff_filespec *one, *two;
1495         one = alloc_filespec(path);
1496         two = alloc_filespec(path);
1497         diff_queue(&diff_queued_diff, one, two);
1498 }