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