builtin-apply.c

   1 /*
   2  * apply.c
   3  *
   4  * Copyright (C) Linus Torvalds, 2005
   5  *
   6  * This applies patches on top of some (arbitrary) version of the SCM.
   7  *
   8  */
   9 #include "cache.h"
  10 #include "cache-tree.h"
  11 #include "quote.h"
  12 #include "blob.h"
  13 #include "delta.h"
  14 #include "builtin.h"
  15
  16 /*
  17  *  --check turns on checking that the working tree matches the
  18  *    files that are being modified, but doesn't apply the patch
  19  *  --stat does just a diffstat, and doesn't actually apply
  20  *  --numstat does numeric diffstat, and doesn't actually apply
  21  *  --index-info shows the old and new index info for paths if available.
  22  *  --index updates the cache as well.
  23  *  --cached updates only the cache without ever touching the working tree.
  24  */
  25 static const char *prefix;
  26 static int prefix_length = -1;
  27 static int newfd = -1;
  28
  29 static int unidiff_zero;
  30 static int p_value = 1;
  31 static int p_value_known;
  32 static int check_index;
  33 static int update_index;
  34 static int cached;
  35 static int diffstat;
  36 static int numstat;
  37 static int summary;
  38 static int check;
  39 static int apply = 1;
  40 static int apply_in_reverse;
  41 static int apply_with_reject;
  42 static int apply_verbosely;
  43 static int no_add;
  44 static const char *fake_ancestor;
  45 static int line_termination = '\n';
  46 static unsigned long p_context = ULONG_MAX;
  47 static const char apply_usage[] =
  48 "git-apply [--stat] [--numstat] [--summary] [--check] [--index] [--cached] [--apply] [--no-add] [--index-info] [--allow-binary-replacement] [--reverse] [--reject] [--verbose] [-z] [-pNUM] [-CNUM] [--whitespace=<nowarn|warn|fix|error|error-all>] <patch>...";
  49
  50 static enum ws_error_action {
  51         nowarn_ws_error,
  52         warn_on_ws_error,
  53         die_on_ws_error,
  54         correct_ws_error,
  55 } ws_error_action = warn_on_ws_error;
  56 static int whitespace_error;
  57 static int squelch_whitespace_errors = 5;
  58 static int applied_after_fixing_ws;
  59 static const char *patch_input_file;
  60
  61 static void parse_whitespace_option(const char *option)
  62 {
  63         if (!option) {
  64                 ws_error_action = warn_on_ws_error;
  65                 return;
  66         }
  67         if (!strcmp(option, "warn")) {
  68                 ws_error_action = warn_on_ws_error;
  69                 return;
  70         }
  71         if (!strcmp(option, "nowarn")) {
  72                 ws_error_action = nowarn_ws_error;
  73                 return;
  74         }
  75         if (!strcmp(option, "error")) {
  76                 ws_error_action = die_on_ws_error;
  77                 return;
  78         }
  79         if (!strcmp(option, "error-all")) {
  80                 ws_error_action = die_on_ws_error;
  81                 squelch_whitespace_errors = 0;
  82                 return;
  83         }
  84         if (!strcmp(option, "strip") || !strcmp(option, "fix")) {
  85                 ws_error_action = correct_ws_error;
  86                 return;
  87         }
  88         die("unrecognized whitespace option '%s'", option);
  89 }
  90
  91 static void set_default_whitespace_mode(const char *whitespace_option)
  92 {
  93         if (!whitespace_option && !apply_default_whitespace)
  94                 ws_error_action = (apply ? warn_on_ws_error : nowarn_ws_error);
  95 }
  96
  97 /*
  98  * For "diff-stat" like behaviour, we keep track of the biggest change
  99  * we've seen, and the longest filename. That allows us to do simple
 100  * scaling.
 101  */
 102 static int max_change, max_len;
 103
 104 /*
 105  * Various "current state", notably line numbers and what
 106  * file (and how) we're patching right now.. The "is_xxxx"
 107  * things are flags, where -1 means "don't know yet".
 108  */
 109 static int linenr = 1;
 110
 111 /*
 112  * This represents one "hunk" from a patch, starting with
 113  * "@@ -oldpos,oldlines +newpos,newlines @@" marker.  The
 114  * patch text is pointed at by patch, and its byte length
 115  * is stored in size.  leading and trailing are the number
 116  * of context lines.
 117  */
 118 struct fragment {
 119         unsigned long leading, trailing;
 120         unsigned long oldpos, oldlines;
 121         unsigned long newpos, newlines;
 122         const char *patch;
 123         int size;
 124         int rejected;
 125         struct fragment *next;
 126 };
 127
 128 /*
 129  * When dealing with a binary patch, we reuse "leading" field
 130  * to store the type of the binary hunk, either deflated "delta"
 131  * or deflated "literal".
 132  */
 133 #define binary_patch_method leading
 134 #define BINARY_DELTA_DEFLATED   1
 135 #define BINARY_LITERAL_DEFLATED 2
 136
 137 /*
 138  * This represents a "patch" to a file, both metainfo changes
 139  * such as creation/deletion, filemode and content changes represented
 140  * as a series of fragments.
 141  */
 142 struct patch {
 143         char *new_name, *old_name, *def_name;
 144         unsigned int old_mode, new_mode;
 145         int is_new, is_delete;  /* -1 = unknown, 0 = false, 1 = true */
 146         int rejected;
 147         unsigned ws_rule;
 148         unsigned long deflate_origlen;
 149         int lines_added, lines_deleted;
 150         int score;
 151         unsigned int is_toplevel_relative:1;
 152         unsigned int inaccurate_eof:1;
 153         unsigned int is_binary:1;
 154         unsigned int is_copy:1;
 155         unsigned int is_rename:1;
 156         struct fragment *fragments;
 157         char *result;
 158         size_t resultsize;
 159         char old_sha1_prefix[41];
 160         char new_sha1_prefix[41];
 161         struct patch *next;
 162 };
 163
 164 static void say_patch_name(FILE *output, const char *pre,
 165                            struct patch *patch, const char *post)
 166 {
 167         fputs(pre, output);
 168         if (patch->old_name && patch->new_name &&
 169             strcmp(patch->old_name, patch->new_name)) {
 170                 quote_c_style(patch->old_name, NULL, output, 0);
 171                 fputs(" => ", output);
 172                 quote_c_style(patch->new_name, NULL, output, 0);
 173         } else {
 174                 const char *n = patch->new_name;
 175                 if (!n)
 176                         n = patch->old_name;
 177                 quote_c_style(n, NULL, output, 0);
 178         }
 179         fputs(post, output);
 180 }
 181
 182 #define CHUNKSIZE (8192)
 183 #define SLOP (16)
 184
 185 static void read_patch_file(struct strbuf *sb, int fd)
 186 {
 187         if (strbuf_read(sb, fd, 0) < 0)
 188                 die("git-apply: read returned %s", strerror(errno));
 189
 190         /*
 191          * Make sure that we have some slop in the buffer
 192          * so that we can do speculative "memcmp" etc, and
 193          * see to it that it is NUL-filled.
 194          */
 195         strbuf_grow(sb, SLOP);
 196         memset(sb->buf + sb->len, 0, SLOP);
 197 }
 198
 199 static unsigned long linelen(const char *buffer, unsigned long size)
 200 {
 201         unsigned long len = 0;
 202         while (size--) {
 203                 len++;
 204                 if (*buffer++ == '\n')
 205                         break;
 206         }
 207         return len;
 208 }
 209
 210 static int is_dev_null(const char *str)
 211 {
 212         return !memcmp("/dev/null", str, 9) && isspace(str[9]);
 213 }
 214
 215 #define TERM_SPACE      1
 216 #define TERM_TAB        2
 217
 218 static int name_terminate(const char *name, int namelen, int c, int terminate)
 219 {
 220         if (c == ' ' && !(terminate & TERM_SPACE))
 221                 return 0;
 222         if (c == '\t' && !(terminate & TERM_TAB))
 223                 return 0;
 224
 225         return 1;
 226 }
 227
 228 static char *find_name(const char *line, char *def, int p_value, int terminate)
 229 {
 230         int len;
 231         const char *start = line;
 232
 233         if (*line == '"') {
 234                 struct strbuf name;
 235
 236                 /*
 237                  * Proposed "new-style" GNU patch/diff format; see
 238                  * http://marc.theaimsgroup.com/?l=git&m=112927316408690&w=2
 239                  */
 240                 strbuf_init(&name, 0);
 241                 if (!unquote_c_style(&name, line, NULL)) {
 242                         char *cp;
 243
 244                         for (cp = name.buf; p_value; p_value--) {
 245                                 cp = strchr(cp, '/');
 246                                 if (!cp)
 247                                         break;
 248                                 cp++;
 249                         }
 250                         if (cp) {
 251                                 /* name can later be freed, so we need
 252                                  * to memmove, not just return cp
 253                                  */
 254                                 strbuf_remove(&name, 0, cp - name.buf);
 255                                 free(def);
 256                                 return strbuf_detach(&name, NULL);
 257                         }
 258                 }
 259                 strbuf_release(&name);
 260         }
 261
 262         for (;;) {
 263                 char c = *line;
 264
 265                 if (isspace(c)) {
 266                         if (c == '\n')
 267                                 break;
 268                         if (name_terminate(start, line-start, c, terminate))
 269                                 break;
 270                 }
 271                 line++;
 272                 if (c == '/' && !--p_value)
 273                         start = line;
 274         }
 275         if (!start)
 276                 return def;
 277         len = line - start;
 278         if (!len)
 279                 return def;
 280
 281         /*
 282          * Generally we prefer the shorter name, especially
 283          * if the other one is just a variation of that with
 284          * something else tacked on to the end (ie "file.orig"
 285          * or "file~").
 286          */
 287         if (def) {
 288                 int deflen = strlen(def);
 289                 if (deflen < len && !strncmp(start, def, deflen))
 290                         return def;
 291                 free(def);
 292         }
 293
 294         return xmemdupz(start, len);
 295 }
 296
 297 static int count_slashes(const char *cp)
 298 {
 299         int cnt = 0;
 300         char ch;
 301
 302         while ((ch = *cp++))
 303                 if (ch == '/')
 304                         cnt++;
 305         return cnt;
 306 }
 307
 308 /*
 309  * Given the string after "--- " or "+++ ", guess the appropriate
 310  * p_value for the given patch.
 311  */
 312 static int guess_p_value(const char *nameline)
 313 {
 314         char *name, *cp;
 315         int val = -1;
 316
 317         if (is_dev_null(nameline))
 318                 return -1;
 319         name = find_name(nameline, NULL, 0, TERM_SPACE | TERM_TAB);
 320         if (!name)
 321                 return -1;
 322         cp = strchr(name, '/');
 323         if (!cp)
 324                 val = 0;
 325         else if (prefix) {
 326                 /*
 327                  * Does it begin with "a/$our-prefix" and such?  Then this is
 328                  * very likely to apply to our directory.
 329                  */
 330                 if (!strncmp(name, prefix, prefix_length))
 331                         val = count_slashes(prefix);
 332                 else {
 333                         cp++;
 334                         if (!strncmp(cp, prefix, prefix_length))
 335                                 val = count_slashes(prefix) + 1;
 336                 }
 337         }
 338         free(name);
 339         return val;
 340 }
 341
 342 /*
 343  * Get the name etc info from the --/+++ lines of a traditional patch header
 344  *
 345  * FIXME! The end-of-filename heuristics are kind of screwy. For existing
 346  * files, we can happily check the index for a match, but for creating a
 347  * new file we should try to match whatever "patch" does. I have no idea.
 348  */
 349 static void parse_traditional_patch(const char *first, const char *second, struct patch *patch)
 350 {
 351         char *name;
 352
 353         first += 4;     /* skip "--- " */
 354         second += 4;    /* skip "+++ " */
 355         if (!p_value_known) {
 356                 int p, q;
 357                 p = guess_p_value(first);
 358                 q = guess_p_value(second);
 359                 if (p < 0) p = q;
 360                 if (0 <= p && p == q) {
 361                         p_value = p;
 362                         p_value_known = 1;
 363                 }
 364         }
 365         if (is_dev_null(first)) {
 366                 patch->is_new = 1;
 367                 patch->is_delete = 0;
 368                 name = find_name(second, NULL, p_value, TERM_SPACE | TERM_TAB);
 369                 patch->new_name = name;
 370         } else if (is_dev_null(second)) {
 371                 patch->is_new = 0;
 372                 patch->is_delete = 1;
 373                 name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);
 374                 patch->old_name = name;
 375         } else {
 376                 name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);
 377                 name = find_name(second, name, p_value, TERM_SPACE | TERM_TAB);
 378                 patch->old_name = patch->new_name = name;
 379         }
 380         if (!name)
 381                 die("unable to find filename in patch at line %d", linenr);
 382 }
 383
 384 static int gitdiff_hdrend(const char *line, struct patch *patch)
 385 {
 386         return -1;
 387 }
 388
 389 /*
 390  * We're anal about diff header consistency, to make
 391  * sure that we don't end up having strange ambiguous
 392  * patches floating around.
 393  *
 394  * As a result, gitdiff_{old|new}name() will check
 395  * their names against any previous information, just
 396  * to make sure..
 397  */
 398 static char *gitdiff_verify_name(const char *line, int isnull, char *orig_name, const char *oldnew)
 399 {
 400         if (!orig_name && !isnull)
 401                 return find_name(line, NULL, p_value, TERM_TAB);
 402
 403         if (orig_name) {
 404                 int len;
 405                 const char *name;
 406                 char *another;
 407                 name = orig_name;
 408                 len = strlen(name);
 409                 if (isnull)
 410                         die("git-apply: bad git-diff - expected /dev/null, got %s on line %d", name, linenr);
 411                 another = find_name(line, NULL, p_value, TERM_TAB);
 412                 if (!another || memcmp(another, name, len))
 413                         die("git-apply: bad git-diff - inconsistent %s filename on line %d", oldnew, linenr);
 414                 free(another);
 415                 return orig_name;
 416         }
 417         else {
 418                 /* expect "/dev/null" */
 419                 if (memcmp("/dev/null", line, 9) || line[9] != '\n')
 420                         die("git-apply: bad git-diff - expected /dev/null on line %d", linenr);
 421                 return NULL;
 422         }
 423 }
 424
 425 static int gitdiff_oldname(const char *line, struct patch *patch)
 426 {
 427         patch->old_name = gitdiff_verify_name(line, patch->is_new, patch->old_name, "old");
 428         return 0;
 429 }
 430
 431 static int gitdiff_newname(const char *line, struct patch *patch)
 432 {
 433         patch->new_name = gitdiff_verify_name(line, patch->is_delete, patch->new_name, "new");
 434         return 0;
 435 }
 436
 437 static int gitdiff_oldmode(const char *line, struct patch *patch)
 438 {
 439         patch->old_mode = strtoul(line, NULL, 8);
 440         return 0;
 441 }
 442
 443 static int gitdiff_newmode(const char *line, struct patch *patch)
 444 {
 445         patch->new_mode = strtoul(line, NULL, 8);
 446         return 0;
 447 }
 448
 449 static int gitdiff_delete(const char *line, struct patch *patch)
 450 {
 451         patch->is_delete = 1;
 452         patch->old_name = patch->def_name;
 453         return gitdiff_oldmode(line, patch);
 454 }
 455
 456 static int gitdiff_newfile(const char *line, struct patch *patch)
 457 {
 458         patch->is_new = 1;
 459         patch->new_name = patch->def_name;
 460         return gitdiff_newmode(line, patch);
 461 }
 462
 463 static int gitdiff_copysrc(const char *line, struct patch *patch)
 464 {
 465         patch->is_copy = 1;
 466         patch->old_name = find_name(line, NULL, 0, 0);
 467         return 0;
 468 }
 469
 470 static int gitdiff_copydst(const char *line, struct patch *patch)
 471 {
 472         patch->is_copy = 1;
 473         patch->new_name = find_name(line, NULL, 0, 0);
 474         return 0;
 475 }
 476
 477 static int gitdiff_renamesrc(const char *line, struct patch *patch)
 478 {
 479         patch->is_rename = 1;
 480         patch->old_name = find_name(line, NULL, 0, 0);
 481         return 0;
 482 }
 483
 484 static int gitdiff_renamedst(const char *line, struct patch *patch)
 485 {
 486         patch->is_rename = 1;
 487         patch->new_name = find_name(line, NULL, 0, 0);
 488         return 0;
 489 }
 490
 491 static int gitdiff_similarity(const char *line, struct patch *patch)
 492 {
 493         if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)
 494                 patch->score = 0;
 495         return 0;
 496 }
 497
 498 static int gitdiff_dissimilarity(const char *line, struct patch *patch)
 499 {
 500         if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)
 501                 patch->score = 0;
 502         return 0;
 503 }
 504
 505 static int gitdiff_index(const char *line, struct patch *patch)
 506 {
 507         /*
 508          * index line is N hexadecimal, "..", N hexadecimal,
 509          * and optional space with octal mode.
 510          */
 511         const char *ptr, *eol;
 512         int len;
 513
 514         ptr = strchr(line, '.');
 515         if (!ptr || ptr[1] != '.' || 40 < ptr - line)
 516                 return 0;
 517         len = ptr - line;
 518         memcpy(patch->old_sha1_prefix, line, len);
 519         patch->old_sha1_prefix[len] = 0;
 520
 521         line = ptr + 2;
 522         ptr = strchr(line, ' ');
 523         eol = strchr(line, '\n');
 524
 525         if (!ptr || eol < ptr)
 526                 ptr = eol;
 527         len = ptr - line;
 528
 529         if (40 < len)
 530                 return 0;
 531         memcpy(patch->new_sha1_prefix, line, len);
 532         patch->new_sha1_prefix[len] = 0;
 533         if (*ptr == ' ')
 534                 patch->new_mode = patch->old_mode = strtoul(ptr+1, NULL, 8);
 535         return 0;
 536 }
 537
 538 /*
 539  * This is normal for a diff that doesn't change anything: we'll fall through
 540  * into the next diff. Tell the parser to break out.
 541  */
 542 static int gitdiff_unrecognized(const char *line, struct patch *patch)
 543 {
 544         return -1;
 545 }
 546
 547 static const char *stop_at_slash(const char *line, int llen)
 548 {
 549         int i;
 550
 551         for (i = 0; i < llen; i++) {
 552                 int ch = line[i];
 553                 if (ch == '/')
 554                         return line + i;
 555         }
 556         return NULL;
 557 }
 558
 559 /*
 560  * This is to extract the same name that appears on "diff --git"
 561  * line.  We do not find and return anything if it is a rename
 562  * patch, and it is OK because we will find the name elsewhere.
 563  * We need to reliably find name only when it is mode-change only,
 564  * creation or deletion of an empty file.  In any of these cases,
 565  * both sides are the same name under a/ and b/ respectively.
 566  */
 567 static char *git_header_name(char *line, int llen)
 568 {
 569         const char *name;
 570         const char *second = NULL;
 571         size_t len;
 572
 573         line += strlen("diff --git ");
 574         llen -= strlen("diff --git ");
 575
 576         if (*line == '"') {
 577                 const char *cp;
 578                 struct strbuf first;
 579                 struct strbuf sp;
 580
 581                 strbuf_init(&first, 0);
 582                 strbuf_init(&sp, 0);
 583
 584                 if (unquote_c_style(&first, line, &second))
 585                         goto free_and_fail1;
 586
 587                 /* advance to the first slash */
 588                 cp = stop_at_slash(first.buf, first.len);
 589                 /* we do not accept absolute paths */
 590                 if (!cp || cp == first.buf)
 591                         goto free_and_fail1;
 592                 strbuf_remove(&first, 0, cp + 1 - first.buf);
 593
 594                 /*
 595                  * second points at one past closing dq of name.
 596                  * find the second name.
 597                  */
 598                 while ((second < line + llen) && isspace(*second))
 599                         second++;
 600
 601                 if (line + llen <= second)
 602                         goto free_and_fail1;
 603                 if (*second == '"') {
 604                         if (unquote_c_style(&sp, second, NULL))
 605                                 goto free_and_fail1;
 606                         cp = stop_at_slash(sp.buf, sp.len);
 607                         if (!cp || cp == sp.buf)
 608                                 goto free_and_fail1;
 609                         /* They must match, otherwise ignore */
 610                         if (strcmp(cp + 1, first.buf))
 611                                 goto free_and_fail1;
 612                         strbuf_release(&sp);
 613                         return strbuf_detach(&first, NULL);
 614                 }
 615
 616                 /* unquoted second */
 617                 cp = stop_at_slash(second, line + llen - second);
 618                 if (!cp || cp == second)
 619                         goto free_and_fail1;
 620                 cp++;
 621                 if (line + llen - cp != first.len + 1 ||
 622                     memcmp(first.buf, cp, first.len))
 623                         goto free_and_fail1;
 624                 return strbuf_detach(&first, NULL);
 625
 626         free_and_fail1:
 627                 strbuf_release(&first);
 628                 strbuf_release(&sp);
 629                 return NULL;
 630         }
 631
 632         /* unquoted first name */
 633         name = stop_at_slash(line, llen);
 634         if (!name || name == line)
 635                 return NULL;
 636         name++;
 637
 638         /*
 639          * since the first name is unquoted, a dq if exists must be
 640          * the beginning of the second name.
 641          */
 642         for (second = name; second < line + llen; second++) {
 643                 if (*second == '"') {
 644                         struct strbuf sp;
 645                         const char *np;
 646
 647                         strbuf_init(&sp, 0);
 648                         if (unquote_c_style(&sp, second, NULL))
 649                                 goto free_and_fail2;
 650
 651                         np = stop_at_slash(sp.buf, sp.len);
 652                         if (!np || np == sp.buf)
 653                                 goto free_and_fail2;
 654                         np++;
 655
 656                         len = sp.buf + sp.len - np;
 657                         if (len < second - name &&
 658                             !strncmp(np, name, len) &&
 659                             isspace(name[len])) {
 660                                 /* Good */
 661                                 strbuf_remove(&sp, 0, np - sp.buf);
 662                                 return strbuf_detach(&sp, NULL);
 663                         }
 664
 665                 free_and_fail2:
 666                         strbuf_release(&sp);
 667                         return NULL;
 668                 }
 669         }
 670
 671         /*
 672          * Accept a name only if it shows up twice, exactly the same
 673          * form.
 674          */
 675         for (len = 0 ; ; len++) {
 676                 switch (name[len]) {
 677                 default:
 678                         continue;
 679                 case '\n':
 680                         return NULL;
 681                 case '\t': case ' ':
 682                         second = name+len;
 683                         for (;;) {
 684                                 char c = *second++;
 685                                 if (c == '\n')
 686                                         return NULL;
 687                                 if (c == '/')
 688                                         break;
 689                         }
 690                         if (second[len] == '\n' && !memcmp(name, second, len)) {
 691                                 return xmemdupz(name, len);
 692                         }
 693                 }
 694         }
 695 }
 696
 697 /* Verify that we recognize the lines following a git header */
 698 static int parse_git_header(char *line, int len, unsigned int size, struct patch *patch)
 699 {
 700         unsigned long offset;
 701
 702         /* A git diff has explicit new/delete information, so we don't guess */
 703         patch->is_new = 0;
 704         patch->is_delete = 0;
 705
 706         /*
 707          * Some things may not have the old name in the
 708          * rest of the headers anywhere (pure mode changes,
 709          * or removing or adding empty files), so we get
 710          * the default name from the header.
 711          */
 712         patch->def_name = git_header_name(line, len);
 713
 714         line += len;
 715         size -= len;
 716         linenr++;
 717         for (offset = len ; size > 0 ; offset += len, size -= len, line += len, linenr++) {
 718                 static const struct opentry {
 719                         const char *str;
 720                         int (*fn)(const char *, struct patch *);
 721                 } optable[] = {
 722                         { "@@ -", gitdiff_hdrend },
 723                         { "--- ", gitdiff_oldname },
 724                         { "+++ ", gitdiff_newname },
 725                         { "old mode ", gitdiff_oldmode },
 726                         { "new mode ", gitdiff_newmode },
 727                         { "deleted file mode ", gitdiff_delete },
 728                         { "new file mode ", gitdiff_newfile },
 729                         { "copy from ", gitdiff_copysrc },
 730                         { "copy to ", gitdiff_copydst },
 731                         { "rename old ", gitdiff_renamesrc },
 732                         { "rename new ", gitdiff_renamedst },
 733                         { "rename from ", gitdiff_renamesrc },
 734                         { "rename to ", gitdiff_renamedst },
 735                         { "similarity index ", gitdiff_similarity },
 736                         { "dissimilarity index ", gitdiff_dissimilarity },
 737                         { "index ", gitdiff_index },
 738                         { "", gitdiff_unrecognized },
 739                 };
 740                 int i;
 741
 742                 len = linelen(line, size);
 743                 if (!len || line[len-1] != '\n')
 744                         break;
 745                 for (i = 0; i < ARRAY_SIZE(optable); i++) {
 746                         const struct opentry *p = optable + i;
 747                         int oplen = strlen(p->str);
 748                         if (len < oplen || memcmp(p->str, line, oplen))
 749                                 continue;
 750                         if (p->fn(line + oplen, patch) < 0)
 751                                 return offset;
 752                         break;
 753                 }
 754         }
 755
 756         return offset;
 757 }
 758
 759 static int parse_num(const char *line, unsigned long *p)
 760 {
 761         char *ptr;
 762
 763         if (!isdigit(*line))
 764                 return 0;
 765         *p = strtoul(line, &ptr, 10);
 766         return ptr - line;
 767 }
 768
 769 static int parse_range(const char *line, int len, int offset, const char *expect,
 770                        unsigned long *p1, unsigned long *p2)
 771 {
 772         int digits, ex;
 773
 774         if (offset < 0 || offset >= len)
 775                 return -1;
 776         line += offset;
 777         len -= offset;
 778
 779         digits = parse_num(line, p1);
 780         if (!digits)
 781                 return -1;
 782
 783         offset += digits;
 784         line += digits;
 785         len -= digits;
 786
 787         *p2 = 1;
 788         if (*line == ',') {
 789                 digits = parse_num(line+1, p2);
 790                 if (!digits)
 791                         return -1;
 792
 793                 offset += digits+1;
 794                 line += digits+1;
 795                 len -= digits+1;
 796         }
 797
 798         ex = strlen(expect);
 799         if (ex > len)
 800                 return -1;
 801         if (memcmp(line, expect, ex))
 802                 return -1;
 803
 804         return offset + ex;
 805 }
 806
 807 /*
 808  * Parse a unified diff fragment header of the
 809  * form "@@ -a,b +c,d @@"
 810  */
 811 static int parse_fragment_header(char *line, int len, struct fragment *fragment)
 812 {
 813         int offset;
 814
 815         if (!len || line[len-1] != '\n')
 816                 return -1;
 817
 818         /* Figure out the number of lines in a fragment */
 819         offset = parse_range(line, len, 4, " +", &fragment->oldpos, &fragment->oldlines);
 820         offset = parse_range(line, len, offset, " @@", &fragment->newpos, &fragment->newlines);
 821
 822         return offset;
 823 }
 824
 825 static int find_header(char *line, unsigned long size, int *hdrsize, struct patch *patch)
 826 {
 827         unsigned long offset, len;
 828
 829         patch->is_toplevel_relative = 0;
 830         patch->is_rename = patch->is_copy = 0;
 831         patch->is_new = patch->is_delete = -1;
 832         patch->old_mode = patch->new_mode = 0;
 833         patch->old_name = patch->new_name = NULL;
 834         for (offset = 0; size > 0; offset += len, size -= len, line += len, linenr++) {
 835                 unsigned long nextlen;
 836
 837                 len = linelen(line, size);
 838                 if (!len)
 839                         break;
 840
 841                 /* Testing this early allows us to take a few shortcuts.. */
 842                 if (len < 6)
 843                         continue;
 844
 845                 /*
 846                  * Make sure we don't find any unconnected patch fragments.
 847                  * That's a sign that we didn't find a header, and that a
 848                  * patch has become corrupted/broken up.
 849                  */
 850                 if (!memcmp("@@ -", line, 4)) {
 851                         struct fragment dummy;
 852                         if (parse_fragment_header(line, len, &dummy) < 0)
 853                                 continue;
 854                         die("patch fragment without header at line %d: %.*s",
 855                             linenr, (int)len-1, line);
 856                 }
 857
 858                 if (size < len + 6)
 859                         break;
 860
 861                 /*
 862                  * Git patch? It might not have a real patch, just a rename
 863                  * or mode change, so we handle that specially
 864                  */
 865                 if (!memcmp("diff --git ", line, 11)) {
 866                         int git_hdr_len = parse_git_header(line, len, size, patch);
 867                         if (git_hdr_len <= len)
 868                                 continue;
 869                         if (!patch->old_name && !patch->new_name) {
 870                                 if (!patch->def_name)
 871                                         die("git diff header lacks filename information (line %d)", linenr);
 872                                 patch->old_name = patch->new_name = patch->def_name;
 873                         }
 874                         patch->is_toplevel_relative = 1;
 875                         *hdrsize = git_hdr_len;
 876                         return offset;
 877                 }
 878
 879                 /* --- followed by +++ ? */
 880                 if (memcmp("--- ", line,  4) || memcmp("+++ ", line + len, 4))
 881                         continue;
 882
 883                 /*
 884                  * We only accept unified patches, so we want it to
 885                  * at least have "@@ -a,b +c,d @@\n", which is 14 chars
 886                  * minimum ("@@ -0,0 +1 @@\n" is the shortest).
 887                  */
 888                 nextlen = linelen(line + len, size - len);
 889                 if (size < nextlen + 14 || memcmp("@@ -", line + len + nextlen, 4))
 890                         continue;
 891
 892                 /* Ok, we'll consider it a patch */
 893                 parse_traditional_patch(line, line+len, patch);
 894                 *hdrsize = len + nextlen;
 895                 linenr += 2;
 896                 return offset;
 897         }
 898         return -1;
 899 }
 900
 901 static void check_whitespace(const char *line, int len, unsigned ws_rule)
 902 {
 903         const char *err = "Adds trailing whitespace";
 904         int seen_space = 0;
 905         int i;
 906
 907         /*
 908          * We know len is at least two, since we have a '+' and we
 909          * checked that the last character was a '\n' before calling
 910          * this function.  That is, an addition of an empty line would
 911          * check the '+' here.  Sneaky...
 912          */
 913         if ((ws_rule & WS_TRAILING_SPACE) && isspace(line[len-2]))
 914                 goto error;
 915
 916         /*
 917          * Make sure that there is no space followed by a tab in
 918          * indentation.
 919          */
 920         if (ws_rule & WS_SPACE_BEFORE_TAB) {
 921                 err = "Space in indent is followed by a tab";
 922                 for (i = 1; i < len; i++) {
 923                         if (line[i] == '\t') {
 924                                 if (seen_space)
 925                                         goto error;
 926                         }
 927                         else if (line[i] == ' ')
 928                                 seen_space = 1;
 929                         else
 930                                 break;
 931                 }
 932         }
 933
 934         /*
 935          * Make sure that the indentation does not contain more than
 936          * 8 spaces.
 937          */
 938         if ((ws_rule & WS_INDENT_WITH_NON_TAB) &&
 939             (8 < len) && !strncmp("+        ", line, 9)) {
 940                 err = "Indent more than 8 places with spaces";
 941                 goto error;
 942         }
 943         return;
 944
 945  error:
 946         whitespace_error++;
 947         if (squelch_whitespace_errors &&
 948             squelch_whitespace_errors < whitespace_error)
 949                 ;
 950         else
 951                 fprintf(stderr, "%s.\n%s:%d:%.*s\n",
 952                         err, patch_input_file, linenr, len-2, line+1);
 953 }
 954
 955 /*
 956  * Parse a unified diff. Note that this really needs to parse each
 957  * fragment separately, since the only way to know the difference
 958  * between a "---" that is part of a patch, and a "---" that starts
 959  * the next patch is to look at the line counts..
 960  */
 961 static int parse_fragment(char *line, unsigned long size,
 962                           struct patch *patch, struct fragment *fragment)
 963 {
 964         int added, deleted;
 965         int len = linelen(line, size), offset;
 966         unsigned long oldlines, newlines;
 967         unsigned long leading, trailing;
 968
 969         offset = parse_fragment_header(line, len, fragment);
 970         if (offset < 0)
 971                 return -1;
 972         oldlines = fragment->oldlines;
 973         newlines = fragment->newlines;
 974         leading = 0;
 975         trailing = 0;
 976
 977         /* Parse the thing.. */
 978         line += len;
 979         size -= len;
 980         linenr++;
 981         added = deleted = 0;
 982         for (offset = len;
 983              0 < size;
 984              offset += len, size -= len, line += len, linenr++) {
 985                 if (!oldlines && !newlines)
 986                         break;
 987                 len = linelen(line, size);
 988                 if (!len || line[len-1] != '\n')
 989                         return -1;
 990                 switch (*line) {
 991                 default:
 992                         return -1;
 993                 case '\n': /* newer GNU diff, an empty context line */
 994                 case ' ':
 995                         oldlines--;
 996                         newlines--;
 997                         if (!deleted && !added)
 998                                 leading++;
 999                         trailing++;
1000                         break;
1001                 case '-':
1002                         if (apply_in_reverse &&
1003                             ws_error_action != nowarn_ws_error)
1004                                 check_whitespace(line, len, patch->ws_rule);
1005                         deleted++;
1006                         oldlines--;
1007                         trailing = 0;
1008                         break;
1009                 case '+':
1010                         if (!apply_in_reverse &&
1011                             ws_error_action != nowarn_ws_error)
1012                                 check_whitespace(line, len, patch->ws_rule);
1013                         added++;
1014                         newlines--;
1015                         trailing = 0;
1016                         break;
1017
1018                 /*
1019                  * We allow "\ No newline at end of file". Depending
1020                  * on locale settings when the patch was produced we
1021                  * don't know what this line looks like. The only
1022                  * thing we do know is that it begins with "\ ".
1023                  * Checking for 12 is just for sanity check -- any
1024                  * l10n of "\ No newline..." is at least that long.
1025                  */
1026                 case '\\':
1027                         if (len < 12 || memcmp(line, "\\ ", 2))
1028                                 return -1;
1029                         break;
1030                 }
1031         }
1032         if (oldlines || newlines)
1033                 return -1;
1034         fragment->leading = leading;
1035         fragment->trailing = trailing;
1036
1037         /*
1038          * If a fragment ends with an incomplete line, we failed to include
1039          * it in the above loop because we hit oldlines == newlines == 0
1040          * before seeing it.
1041          */
1042         if (12 < size && !memcmp(line, "\\ ", 2))
1043                 offset += linelen(line, size);
1044
1045         patch->lines_added += added;
1046         patch->lines_deleted += deleted;
1047
1048         if (0 < patch->is_new && oldlines)
1049                 return error("new file depends on old contents");
1050         if (0 < patch->is_delete && newlines)
1051                 return error("deleted file still has contents");
1052         return offset;
1053 }
1054
1055 static int parse_single_patch(char *line, unsigned long size, struct patch *patch)
1056 {
1057         unsigned long offset = 0;
1058         unsigned long oldlines = 0, newlines = 0, context = 0;
1059         struct fragment **fragp = &patch->fragments;
1060
1061         while (size > 4 && !memcmp(line, "@@ -", 4)) {
1062                 struct fragment *fragment;
1063                 int len;
1064
1065                 fragment = xcalloc(1, sizeof(*fragment));
1066                 len = parse_fragment(line, size, patch, fragment);
1067                 if (len <= 0)
1068                         die("corrupt patch at line %d", linenr);
1069                 fragment->patch = line;
1070                 fragment->size = len;
1071                 oldlines += fragment->oldlines;
1072                 newlines += fragment->newlines;
1073                 context += fragment->leading + fragment->trailing;
1074
1075                 *fragp = fragment;
1076                 fragp = &fragment->next;
1077
1078                 offset += len;
1079                 line += len;
1080                 size -= len;
1081         }
1082
1083         /*
1084          * If something was removed (i.e. we have old-lines) it cannot
1085          * be creation, and if something was added it cannot be
1086          * deletion.  However, the reverse is not true; --unified=0
1087          * patches that only add are not necessarily creation even
1088          * though they do not have any old lines, and ones that only
1089          * delete are not necessarily deletion.
1090          *
1091          * Unfortunately, a real creation/deletion patch do _not_ have
1092          * any context line by definition, so we cannot safely tell it
1093          * apart with --unified=0 insanity.  At least if the patch has
1094          * more than one hunk it is not creation or deletion.
1095          */
1096         if (patch->is_new < 0 &&
1097             (oldlines || (patch->fragments && patch->fragments->next)))
1098                 patch->is_new = 0;
1099         if (patch->is_delete < 0 &&
1100             (newlines || (patch->fragments && patch->fragments->next)))
1101                 patch->is_delete = 0;
1102         if (!unidiff_zero || context) {
1103                 /* If the user says the patch is not generated with
1104                  * --unified=0, or if we have seen context lines,
1105                  * then not having oldlines means the patch is creation,
1106                  * and not having newlines means the patch is deletion.
1107                  */
1108                 if (patch->is_new < 0 && !oldlines) {
1109                         patch->is_new = 1;
1110                         patch->old_name = NULL;
1111                 }
1112                 if (patch->is_delete < 0 && !newlines) {
1113                         patch->is_delete = 1;
1114                         patch->new_name = NULL;
1115                 }
1116         }
1117
1118         if (0 < patch->is_new && oldlines)
1119                 die("new file %s depends on old contents", patch->new_name);
1120         if (0 < patch->is_delete && newlines)
1121                 die("deleted file %s still has contents", patch->old_name);
1122         if (!patch->is_delete && !newlines && context)
1123                 fprintf(stderr, "** warning: file %s becomes empty but "
1124                         "is not deleted\n", patch->new_name);
1125
1126         return offset;
1127 }
1128
1129 static inline int metadata_changes(struct patch *patch)
1130 {
1131         return  patch->is_rename > 0 ||
1132                 patch->is_copy > 0 ||
1133                 patch->is_new > 0 ||
1134                 patch->is_delete ||
1135                 (patch->old_mode && patch->new_mode &&
1136                  patch->old_mode != patch->new_mode);
1137 }
1138
1139 static char *inflate_it(const void *data, unsigned long size,
1140                         unsigned long inflated_size)
1141 {
1142         z_stream stream;
1143         void *out;
1144         int st;
1145
1146         memset(&stream, 0, sizeof(stream));
1147
1148         stream.next_in = (unsigned char *)data;
1149         stream.avail_in = size;
1150         stream.next_out = out = xmalloc(inflated_size);
1151         stream.avail_out = inflated_size;
1152         inflateInit(&stream);
1153         st = inflate(&stream, Z_FINISH);
1154         if ((st != Z_STREAM_END) || stream.total_out != inflated_size) {
1155                 free(out);
1156                 return NULL;
1157         }
1158         return out;
1159 }
1160
1161 static struct fragment *parse_binary_hunk(char **buf_p,
1162                                           unsigned long *sz_p,
1163                                           int *status_p,
1164                                           int *used_p)
1165 {
1166         /*
1167          * Expect a line that begins with binary patch method ("literal"
1168          * or "delta"), followed by the length of data before deflating.
1169          * a sequence of 'length-byte' followed by base-85 encoded data
1170          * should follow, terminated by a newline.
1171          *
1172          * Each 5-byte sequence of base-85 encodes up to 4 bytes,
1173          * and we would limit the patch line to 66 characters,
1174          * so one line can fit up to 13 groups that would decode
1175          * to 52 bytes max.  The length byte 'A'-'Z' corresponds
1176          * to 1-26 bytes, and 'a'-'z' corresponds to 27-52 bytes.
1177          */
1178         int llen, used;
1179         unsigned long size = *sz_p;
1180         char *buffer = *buf_p;
1181         int patch_method;
1182         unsigned long origlen;
1183         char *data = NULL;
1184         int hunk_size = 0;
1185         struct fragment *frag;
1186
1187         llen = linelen(buffer, size);
1188         used = llen;
1189
1190         *status_p = 0;
1191
1192         if (!prefixcmp(buffer, "delta ")) {
1193                 patch_method = BINARY_DELTA_DEFLATED;
1194                 origlen = strtoul(buffer + 6, NULL, 10);
1195         }
1196         else if (!prefixcmp(buffer, "literal ")) {
1197                 patch_method = BINARY_LITERAL_DEFLATED;
1198                 origlen = strtoul(buffer + 8, NULL, 10);
1199         }
1200         else
1201                 return NULL;
1202
1203         linenr++;
1204         buffer += llen;
1205         while (1) {
1206                 int byte_length, max_byte_length, newsize;
1207                 llen = linelen(buffer, size);
1208                 used += llen;
1209                 linenr++;
1210                 if (llen == 1) {
1211                         /* consume the blank line */
1212                         buffer++;
1213                         size--;
1214                         break;
1215                 }
1216                 /*
1217                  * Minimum line is "A00000\n" which is 7-byte long,
1218                  * and the line length must be multiple of 5 plus 2.
1219                  */
1220                 if ((llen < 7) || (llen-2) % 5)
1221                         goto corrupt;
1222                 max_byte_length = (llen - 2) / 5 * 4;
1223                 byte_length = *buffer;
1224                 if ('A' <= byte_length && byte_length <= 'Z')
1225                         byte_length = byte_length - 'A' + 1;
1226                 else if ('a' <= byte_length && byte_length <= 'z')
1227                         byte_length = byte_length - 'a' + 27;
1228                 else
1229                         goto corrupt;
1230                 /* if the input length was not multiple of 4, we would
1231                  * have filler at the end but the filler should never
1232                  * exceed 3 bytes
1233                  */
1234                 if (max_byte_length < byte_length ||
1235                     byte_length <= max_byte_length - 4)
1236                         goto corrupt;
1237                 newsize = hunk_size + byte_length;
1238                 data = xrealloc(data, newsize);
1239                 if (decode_85(data + hunk_size, buffer + 1, byte_length))
1240                         goto corrupt;
1241                 hunk_size = newsize;
1242                 buffer += llen;
1243                 size -= llen;
1244         }
1245
1246         frag = xcalloc(1, sizeof(*frag));
1247         frag->patch = inflate_it(data, hunk_size, origlen);
1248         if (!frag->patch)
1249                 goto corrupt;
1250         free(data);
1251         frag->size = origlen;
1252         *buf_p = buffer;
1253         *sz_p = size;
1254         *used_p = used;
1255         frag->binary_patch_method = patch_method;
1256         return frag;
1257
1258  corrupt:
1259         free(data);
1260         *status_p = -1;
1261         error("corrupt binary patch at line %d: %.*s",
1262               linenr-1, llen-1, buffer);
1263         return NULL;
1264 }
1265
1266 static int parse_binary(char *buffer, unsigned long size, struct patch *patch)
1267 {
1268         /*
1269          * We have read "GIT binary patch\n"; what follows is a line
1270          * that says the patch method (currently, either "literal" or
1271          * "delta") and the length of data before deflating; a
1272          * sequence of 'length-byte' followed by base-85 encoded data
1273          * follows.
1274          *
1275          * When a binary patch is reversible, there is another binary
1276          * hunk in the same format, starting with patch method (either
1277          * "literal" or "delta") with the length of data, and a sequence
1278          * of length-byte + base-85 encoded data, terminated with another
1279          * empty line.  This data, when applied to the postimage, produces
1280          * the preimage.
1281          */
1282         struct fragment *forward;
1283         struct fragment *reverse;
1284         int status;
1285         int used, used_1;
1286
1287         forward = parse_binary_hunk(&buffer, &size, &status, &used);
1288         if (!forward && !status)
1289                 /* there has to be one hunk (forward hunk) */
1290                 return error("unrecognized binary patch at line %d", linenr-1);
1291         if (status)
1292                 /* otherwise we already gave an error message */
1293                 return status;
1294
1295         reverse = parse_binary_hunk(&buffer, &size, &status, &used_1);
1296         if (reverse)
1297                 used += used_1;
1298         else if (status) {
1299                 /*
1300                  * Not having reverse hunk is not an error, but having
1301                  * a corrupt reverse hunk is.
1302                  */
1303                 free((void*) forward->patch);
1304                 free(forward);
1305                 return status;
1306         }
1307         forward->next = reverse;
1308         patch->fragments = forward;
1309         patch->is_binary = 1;
1310         return used;
1311 }
1312
1313 static int parse_chunk(char *buffer, unsigned long size, struct patch *patch)
1314 {
1315         int hdrsize, patchsize;
1316         int offset = find_header(buffer, size, &hdrsize, patch);
1317
1318         if (offset < 0)
1319                 return offset;
1320
1321         patch->ws_rule = whitespace_rule(patch->new_name
1322                                          ? patch->new_name
1323                                          : patch->old_name);
1324
1325         patchsize = parse_single_patch(buffer + offset + hdrsize,
1326                                        size - offset - hdrsize, patch);
1327
1328         if (!patchsize) {
1329                 static const char *binhdr[] = {
1330                         "Binary files ",
1331                         "Files ",
1332                         NULL,
1333                 };
1334                 static const char git_binary[] = "GIT binary patch\n";
1335                 int i;
1336                 int hd = hdrsize + offset;
1337                 unsigned long llen = linelen(buffer + hd, size - hd);
1338
1339                 if (llen == sizeof(git_binary) - 1 &&
1340                     !memcmp(git_binary, buffer + hd, llen)) {
1341                         int used;
1342                         linenr++;
1343                         used = parse_binary(buffer + hd + llen,
1344                                             size - hd - llen, patch);
1345                         if (used)
1346                                 patchsize = used + llen;
1347                         else
1348                                 patchsize = 0;
1349                 }
1350                 else if (!memcmp(" differ\n", buffer + hd + llen - 8, 8)) {
1351                         for (i = 0; binhdr[i]; i++) {
1352                                 int len = strlen(binhdr[i]);
1353                                 if (len < size - hd &&
1354                                     !memcmp(binhdr[i], buffer + hd, len)) {
1355                                         linenr++;
1356                                         patch->is_binary = 1;
1357                                         patchsize = llen;
1358                                         break;
1359                                 }
1360                         }
1361                 }
1362
1363                 /* Empty patch cannot be applied if it is a text patch
1364                  * without metadata change.  A binary patch appears
1365                  * empty to us here.
1366                  */
1367                 if ((apply || check) &&
1368                     (!patch->is_binary && !metadata_changes(patch)))
1369                         die("patch with only garbage at line %d", linenr);
1370         }
1371
1372         return offset + hdrsize + patchsize;
1373 }
1374
1375 #define swap(a,b) myswap((a),(b),sizeof(a))
1376
1377 #define myswap(a, b, size) do {         \
1378         unsigned char mytmp[size];      \
1379         memcpy(mytmp, &a, size);                \
1380         memcpy(&a, &b, size);           \
1381         memcpy(&b, mytmp, size);                \
1382 } while (0)
1383
1384 static void reverse_patches(struct patch *p)
1385 {
1386         for (; p; p = p->next) {
1387                 struct fragment *frag = p->fragments;
1388
1389                 swap(p->new_name, p->old_name);
1390                 swap(p->new_mode, p->old_mode);
1391                 swap(p->is_new, p->is_delete);
1392                 swap(p->lines_added, p->lines_deleted);
1393                 swap(p->old_sha1_prefix, p->new_sha1_prefix);
1394
1395                 for (; frag; frag = frag->next) {
1396                         swap(frag->newpos, frag->oldpos);
1397                         swap(frag->newlines, frag->oldlines);
1398                 }
1399         }
1400 }
1401
1402 static const char pluses[] =
1403 "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
1404 static const char minuses[]=
1405 "----------------------------------------------------------------------";
1406
1407 static void show_stats(struct patch *patch)
1408 {
1409         struct strbuf qname;
1410         char *cp = patch->new_name ? patch->new_name : patch->old_name;
1411         int max, add, del;
1412
1413         strbuf_init(&qname, 0);
1414         quote_c_style(cp, &qname, NULL, 0);
1415
1416         /*
1417          * "scale" the filename
1418          */
1419         max = max_len;
1420         if (max > 50)
1421                 max = 50;
1422
1423         if (qname.len > max) {
1424                 cp = strchr(qname.buf + qname.len + 3 - max, '/');
1425                 if (!cp)
1426                         cp = qname.buf + qname.len + 3 - max;
1427                 strbuf_splice(&qname, 0, cp - qname.buf, "...", 3);
1428         }
1429
1430         if (patch->is_binary) {
1431                 printf(" %-*s |  Bin\n", max, qname.buf);
1432                 strbuf_release(&qname);
1433                 return;
1434         }
1435
1436         printf(" %-*s |", max, qname.buf);
1437         strbuf_release(&qname);
1438
1439         /*
1440          * scale the add/delete
1441          */
1442         max = max + max_change > 70 ? 70 - max : max_change;
1443         add = patch->lines_added;
1444         del = patch->lines_deleted;
1445
1446         if (max_change > 0) {
1447                 int total = ((add + del) * max + max_change / 2) / max_change;
1448                 add = (add * max + max_change / 2) / max_change;
1449                 del = total - add;
1450         }
1451         printf("%5d %.*s%.*s\n", patch->lines_added + patch->lines_deleted,
1452                 add, pluses, del, minuses);
1453 }
1454
1455 static int read_old_data(struct stat *st, const char *path, struct strbuf *buf)
1456 {
1457         switch (st->st_mode & S_IFMT) {
1458         case S_IFLNK:
1459                 strbuf_grow(buf, st->st_size);
1460                 if (readlink(path, buf->buf, st->st_size) != st->st_size)
1461                         return -1;
1462                 strbuf_setlen(buf, st->st_size);
1463                 return 0;
1464         case S_IFREG:
1465                 if (strbuf_read_file(buf, path, st->st_size) != st->st_size)
1466                         return error("unable to open or read %s", path);
1467                 convert_to_git(path, buf->buf, buf->len, buf);
1468                 return 0;
1469         default:
1470                 return -1;
1471         }
1472 }
1473
1474 static int find_offset(const char *buf, unsigned long size,
1475                        const char *fragment, unsigned long fragsize,
1476                        int line, int *lines)
1477 {
1478         int i;
1479         unsigned long start, backwards, forwards;
1480
1481         if (fragsize > size)
1482                 return -1;
1483
1484         start = 0;
1485         if (line > 1) {
1486                 unsigned long offset = 0;
1487                 i = line-1;
1488                 while (offset + fragsize <= size) {
1489                         if (buf[offset++] == '\n') {
1490                                 start = offset;
1491                                 if (!--i)
1492                                         break;
1493                         }
1494                 }
1495         }
1496
1497         /* Exact line number? */
1498         if ((start + fragsize <= size) &&
1499             !memcmp(buf + start, fragment, fragsize))
1500                 return start;
1501
1502         /*
1503          * There's probably some smart way to do this, but I'll leave
1504          * that to the smart and beautiful people. I'm simple and stupid.
1505          */
1506         backwards = start;
1507         forwards = start;
1508         for (i = 0; ; i++) {
1509                 unsigned long try;
1510                 int n;
1511
1512                 /* "backward" */
1513                 if (i & 1) {
1514                         if (!backwards) {
1515                                 if (forwards + fragsize > size)
1516                                         break;
1517                                 continue;
1518                         }
1519                         do {
1520                                 --backwards;
1521                         } while (backwards && buf[backwards-1] != '\n');
1522                         try = backwards;
1523                 } else {
1524                         while (forwards + fragsize <= size) {
1525                                 if (buf[forwards++] == '\n')
1526                                         break;
1527                         }
1528                         try = forwards;
1529                 }
1530
1531                 if (try + fragsize > size)
1532                         continue;
1533                 if (memcmp(buf + try, fragment, fragsize))
1534                         continue;
1535                 n = (i >> 1)+1;
1536                 if (i & 1)
1537                         n = -n;
1538                 *lines = n;
1539                 return try;
1540         }
1541
1542         /*
1543          * We should start searching forward and backward.
1544          */
1545         return -1;
1546 }
1547
1548 static void remove_first_line(const char **rbuf, int *rsize)
1549 {
1550         const char *buf = *rbuf;
1551         int size = *rsize;
1552         unsigned long offset;
1553         offset = 0;
1554         while (offset <= size) {
1555                 if (buf[offset++] == '\n')
1556                         break;
1557         }
1558         *rsize = size - offset;
1559         *rbuf = buf + offset;
1560 }
1561
1562 static void remove_last_line(const char **rbuf, int *rsize)
1563 {
1564         const char *buf = *rbuf;
1565         int size = *rsize;
1566         unsigned long offset;
1567         offset = size - 1;
1568         while (offset > 0) {
1569                 if (buf[--offset] == '\n')
1570                         break;
1571         }
1572         *rsize = offset + 1;
1573 }
1574
1575 static int apply_line(char *output, const char *patch, int plen,
1576                       unsigned ws_rule)
1577 {
1578         /*
1579          * plen is number of bytes to be copied from patch,
1580          * starting at patch+1 (patch[0] is '+').  Typically
1581          * patch[plen] is '\n', unless this is the incomplete
1582          * last line.
1583          */
1584         int i;
1585         int add_nl_to_tail = 0;
1586         int fixed = 0;
1587         int last_tab_in_indent = -1;
1588         int last_space_in_indent = -1;
1589         int need_fix_leading_space = 0;
1590         char *buf;
1591
1592         if ((ws_error_action != correct_ws_error) || !whitespace_error ||
1593             *patch != '+') {
1594                 memcpy(output, patch + 1, plen);
1595                 return plen;
1596         }
1597
1598         /*
1599          * Strip trailing whitespace
1600          */
1601         if ((ws_rule & WS_TRAILING_SPACE) &&
1602             (1 < plen && isspace(patch[plen-1]))) {
1603                 if (patch[plen] == '\n')
1604                         add_nl_to_tail = 1;
1605                 plen--;
1606                 while (0 < plen && isspace(patch[plen]))
1607                         plen--;
1608                 fixed = 1;
1609         }
1610
1611         /*
1612          * Check leading whitespaces (indent)
1613          */
1614         for (i = 1; i < plen; i++) {
1615                 char ch = patch[i];
1616                 if (ch == '\t') {
1617                         last_tab_in_indent = i;
1618                         if ((ws_rule & WS_SPACE_BEFORE_TAB) &&
1619                             0 <= last_space_in_indent)
1620                             need_fix_leading_space = 1;
1621                 } else if (ch == ' ') {
1622                         last_space_in_indent = i;
1623                         if ((ws_rule & WS_INDENT_WITH_NON_TAB) &&
1624                             last_tab_in_indent < 0 &&
1625                             8 <= i)
1626                                 need_fix_leading_space = 1;
1627                 }
1628                 else
1629                         break;
1630         }
1631
1632         buf = output;
1633         if (need_fix_leading_space) {
1634                 int consecutive_spaces = 0;
1635                 int last = last_tab_in_indent + 1;
1636
1637                 if (ws_rule & WS_INDENT_WITH_NON_TAB) {
1638                         /* have "last" point at one past the indent */
1639                         if (last_tab_in_indent < last_space_in_indent)
1640                                 last = last_space_in_indent + 1;
1641                         else
1642                                 last = last_tab_in_indent + 1;
1643                 }
1644
1645                 /*
1646                  * between patch[1..last], strip the funny spaces,
1647                  * updating them to tab as needed.
1648                  */
1649                 for (i = 1; i < last; i++, plen--) {
1650                         char ch = patch[i];
1651                         if (ch != ' ') {
1652                                 consecutive_spaces = 0;
1653                                 *output++ = ch;
1654                         } else {
1655                                 consecutive_spaces++;
1656                                 if (consecutive_spaces == 8) {
1657                                         *output++ = '\t';
1658                                         consecutive_spaces = 0;
1659                                 }
1660                         }
1661                 }
1662                 while (0 < consecutive_spaces--)
1663                         *output++ = ' ';
1664                 fixed = 1;
1665                 i = last;
1666         }
1667         else
1668                 i = 1;
1669
1670         memcpy(output, patch + i, plen);
1671         if (add_nl_to_tail)
1672                 output[plen++] = '\n';
1673         if (fixed)
1674                 applied_after_fixing_ws++;
1675         return output + plen - buf;
1676 }
1677
1678 static int apply_one_fragment(struct strbuf *buf, struct fragment *frag,
1679                               int inaccurate_eof, unsigned ws_rule)
1680 {
1681         int match_beginning, match_end;
1682         const char *patch = frag->patch;
1683         int offset, size = frag->size;
1684         char *old = xmalloc(size);
1685         char *new = xmalloc(size);
1686         const char *oldlines, *newlines;
1687         int oldsize = 0, newsize = 0;
1688         int new_blank_lines_at_end = 0;
1689         unsigned long leading, trailing;
1690         int pos, lines;
1691
1692         while (size > 0) {
1693                 char first;
1694                 int len = linelen(patch, size);
1695                 int plen;
1696                 int added_blank_line = 0;
1697
1698                 if (!len)
1699                         break;
1700
1701                 /*
1702                  * "plen" is how much of the line we should use for
1703                  * the actual patch data. Normally we just remove the
1704                  * first character on the line, but if the line is
1705                  * followed by "\ No newline", then we also remove the
1706                  * last one (which is the newline, of course).
1707                  */
1708                 plen = len-1;
1709                 if (len < size && patch[len] == '\\')
1710                         plen--;
1711                 first = *patch;
1712                 if (apply_in_reverse) {
1713                         if (first == '-')
1714                                 first = '+';
1715                         else if (first == '+')
1716                                 first = '-';
1717                 }
1718
1719                 switch (first) {
1720                 case '\n':
1721                         /* Newer GNU diff, empty context line */
1722                         if (plen < 0)
1723                                 /* ... followed by '\No newline'; nothing */
1724                                 break;
1725                         old[oldsize++] = '\n';
1726                         new[newsize++] = '\n';
1727                         break;
1728                 case ' ':
1729                 case '-':
1730                         memcpy(old + oldsize, patch + 1, plen);
1731                         oldsize += plen;
1732                         if (first == '-')
1733                                 break;
1734                 /* Fall-through for ' ' */
1735                 case '+':
1736                         if (first != '+' || !no_add) {
1737                                 int added = apply_line(new + newsize, patch,
1738                                                        plen, ws_rule);
1739                                 newsize += added;
1740                                 if (first == '+' &&
1741                                     added == 1 && new[newsize-1] == '\n')
1742                                         added_blank_line = 1;
1743                         }
1744                         break;
1745                 case '@': case '\\':
1746                         /* Ignore it, we already handled it */
1747                         break;
1748                 default:
1749                         if (apply_verbosely)
1750                                 error("invalid start of line: '%c'", first);
1751                         return -1;
1752                 }
1753                 if (added_blank_line)
1754                         new_blank_lines_at_end++;
1755                 else
1756                         new_blank_lines_at_end = 0;
1757                 patch += len;
1758                 size -= len;
1759         }
1760
1761         if (inaccurate_eof &&
1762             oldsize > 0 && old[oldsize - 1] == '\n' &&
1763             newsize > 0 && new[newsize - 1] == '\n') {
1764                 oldsize--;
1765                 newsize--;
1766         }
1767
1768         oldlines = old;
1769         newlines = new;
1770         leading = frag->leading;
1771         trailing = frag->trailing;
1772
1773         /*
1774          * If we don't have any leading/trailing data in the patch,
1775          * we want it to match at the beginning/end of the file.
1776          *
1777          * But that would break if the patch is generated with
1778          * --unified=0; sane people wouldn't do that to cause us
1779          * trouble, but we try to please not so sane ones as well.
1780          */
1781         if (unidiff_zero) {
1782                 match_beginning = (!leading && !frag->oldpos);
1783                 match_end = 0;
1784         }
1785         else {
1786                 match_beginning = !leading && (frag->oldpos == 1);
1787                 match_end = !trailing;
1788         }
1789
1790         lines = 0;
1791         pos = frag->newpos;
1792         for (;;) {
1793                 offset = find_offset(buf->buf, buf->len,
1794                                      oldlines, oldsize, pos, &lines);
1795                 if (match_end && offset + oldsize != buf->len)
1796                         offset = -1;
1797                 if (match_beginning && offset)
1798                         offset = -1;
1799                 if (offset >= 0) {
1800                         if (ws_error_action == correct_ws_error &&
1801                             (buf->len - oldsize - offset == 0)) /* end of file? */
1802                                 newsize -= new_blank_lines_at_end;
1803
1804                         /* Warn if it was necessary to reduce the number
1805                          * of context lines.
1806                          */
1807                         if ((leading != frag->leading) ||
1808                             (trailing != frag->trailing))
1809                                 fprintf(stderr, "Context reduced to (%ld/%ld)"
1810                                         " to apply fragment at %d\n",
1811                                         leading, trailing, pos + lines);
1812
1813                         strbuf_splice(buf, offset, oldsize, newlines, newsize);
1814                         offset = 0;
1815                         break;
1816                 }
1817
1818                 /* Am I at my context limits? */
1819                 if ((leading <= p_context) && (trailing <= p_context))
1820                         break;
1821                 if (match_beginning || match_end) {
1822                         match_beginning = match_end = 0;
1823                         continue;
1824                 }
1825                 /*
1826                  * Reduce the number of context lines; reduce both
1827                  * leading and trailing if they are equal otherwise
1828                  * just reduce the larger context.
1829                  */
1830                 if (leading >= trailing) {
1831                         remove_first_line(&oldlines, &oldsize);
1832                         remove_first_line(&newlines, &newsize);
1833                         pos--;
1834                         leading--;
1835                 }
1836                 if (trailing > leading) {
1837                         remove_last_line(&oldlines, &oldsize);
1838                         remove_last_line(&newlines, &newsize);
1839                         trailing--;
1840                 }
1841         }
1842
1843         if (offset && apply_verbosely)
1844                 error("while searching for:\n%.*s", oldsize, oldlines);
1845
1846         free(old);
1847         free(new);
1848         return offset;
1849 }
1850
1851 static int apply_binary_fragment(struct strbuf *buf, struct patch *patch)
1852 {
1853         struct fragment *fragment = patch->fragments;
1854         unsigned long len;
1855         void *dst;
1856
1857         /* Binary patch is irreversible without the optional second hunk */
1858         if (apply_in_reverse) {
1859                 if (!fragment->next)
1860                         return error("cannot reverse-apply a binary patch "
1861                                      "without the reverse hunk to '%s'",
1862                                      patch->new_name
1863                                      ? patch->new_name : patch->old_name);
1864                 fragment = fragment->next;
1865         }
1866         switch (fragment->binary_patch_method) {
1867         case BINARY_DELTA_DEFLATED:
1868                 dst = patch_delta(buf->buf, buf->len, fragment->patch,
1869                                   fragment->size, &len);
1870                 if (!dst)
1871                         return -1;
1872                 /* XXX patch_delta NUL-terminates */
1873                 strbuf_attach(buf, dst, len, len + 1);
1874                 return 0;
1875         case BINARY_LITERAL_DEFLATED:
1876                 strbuf_reset(buf);
1877                 strbuf_add(buf, fragment->patch, fragment->size);
1878                 return 0;
1879         }
1880         return -1;
1881 }
1882
1883 static int apply_binary(struct strbuf *buf, struct patch *patch)
1884 {
1885         const char *name = patch->old_name ? patch->old_name : patch->new_name;
1886         unsigned char sha1[20];
1887
1888         /*
1889          * For safety, we require patch index line to contain
1890          * full 40-byte textual SHA1 for old and new, at least for now.
1891          */
1892         if (strlen(patch->old_sha1_prefix) != 40 ||
1893             strlen(patch->new_sha1_prefix) != 40 ||
1894             get_sha1_hex(patch->old_sha1_prefix, sha1) ||
1895             get_sha1_hex(patch->new_sha1_prefix, sha1))
1896                 return error("cannot apply binary patch to '%s' "
1897                              "without full index line", name);
1898
1899         if (patch->old_name) {
1900                 /*
1901                  * See if the old one matches what the patch
1902                  * applies to.
1903                  */
1904                 hash_sha1_file(buf->buf, buf->len, blob_type, sha1);
1905                 if (strcmp(sha1_to_hex(sha1), patch->old_sha1_prefix))
1906                         return error("the patch applies to '%s' (%s), "
1907                                      "which does not match the "
1908                                      "current contents.",
1909                                      name, sha1_to_hex(sha1));
1910         }
1911         else {
1912                 /* Otherwise, the old one must be empty. */
1913                 if (buf->len)
1914                         return error("the patch applies to an empty "
1915                                      "'%s' but it is not empty", name);
1916         }
1917
1918         get_sha1_hex(patch->new_sha1_prefix, sha1);
1919         if (is_null_sha1(sha1)) {
1920                 strbuf_release(buf);
1921                 return 0; /* deletion patch */
1922         }
1923
1924         if (has_sha1_file(sha1)) {
1925                 /* We already have the postimage */
1926                 enum object_type type;
1927                 unsigned long size;
1928                 char *result;
1929
1930                 result = read_sha1_file(sha1, &type, &size);
1931                 if (!result)
1932                         return error("the necessary postimage %s for "
1933                                      "'%s' cannot be read",
1934                                      patch->new_sha1_prefix, name);
1935                 /* XXX read_sha1_file NUL-terminates */
1936                 strbuf_attach(buf, result, size, size + 1);
1937         } else {
1938                 /*
1939                  * We have verified buf matches the preimage;
1940                  * apply the patch data to it, which is stored
1941                  * in the patch->fragments->{patch,size}.
1942                  */
1943                 if (apply_binary_fragment(buf, patch))
1944                         return error("binary patch does not apply to '%s'",
1945                                      name);
1946
1947                 /* verify that the result matches */
1948                 hash_sha1_file(buf->buf, buf->len, blob_type, sha1);
1949                 if (strcmp(sha1_to_hex(sha1), patch->new_sha1_prefix))
1950                         return error("binary patch to '%s' creates incorrect result (expecting %s, got %s)",
1951                                 name, patch->new_sha1_prefix, sha1_to_hex(sha1));
1952         }
1953
1954         return 0;
1955 }
1956
1957 static int apply_fragments(struct strbuf *buf, struct patch *patch)
1958 {
1959         struct fragment *frag = patch->fragments;
1960         const char *name = patch->old_name ? patch->old_name : patch->new_name;
1961         unsigned ws_rule = patch->ws_rule;
1962         unsigned inaccurate_eof = patch->inaccurate_eof;
1963
1964         if (patch->is_binary)
1965                 return apply_binary(buf, patch);
1966
1967         while (frag) {
1968                 if (apply_one_fragment(buf, frag, inaccurate_eof, ws_rule)) {
1969                         error("patch failed: %s:%ld", name, frag->oldpos);
1970                         if (!apply_with_reject)
1971                                 return -1;
1972                         frag->rejected = 1;
1973                 }
1974                 frag = frag->next;
1975         }
1976         return 0;
1977 }
1978
1979 static int read_file_or_gitlink(struct cache_entry *ce, struct strbuf *buf)
1980 {
1981         if (!ce)
1982                 return 0;
1983
1984         if (S_ISGITLINK(ntohl(ce->ce_mode))) {
1985                 strbuf_grow(buf, 100);
1986                 strbuf_addf(buf, "Subproject commit %s\n", sha1_to_hex(ce->sha1));
1987         } else {
1988                 enum object_type type;
1989                 unsigned long sz;
1990                 char *result;
1991
1992                 result = read_sha1_file(ce->sha1, &type, &sz);
1993                 if (!result)
1994                         return -1;
1995                 /* XXX read_sha1_file NUL-terminates */
1996                 strbuf_attach(buf, result, sz, sz + 1);
1997         }
1998         return 0;
1999 }
2000
2001 static int apply_data(struct patch *patch, struct stat *st, struct cache_entry *ce)
2002 {
2003         struct strbuf buf;
2004
2005         strbuf_init(&buf, 0);
2006         if (cached) {
2007                 if (read_file_or_gitlink(ce, &buf))
2008                         return error("read of %s failed", patch->old_name);
2009         } else if (patch->old_name) {
2010                 if (S_ISGITLINK(patch->old_mode)) {
2011                         if (ce) {
2012                                 read_file_or_gitlink(ce, &buf);
2013                         } else {
2014                                 /*
2015                                  * There is no way to apply subproject
2016                                  * patch without looking at the index.
2017                                  */
2018                                 patch->fragments = NULL;
2019                         }
2020                 } else {
2021                         if (read_old_data(st, patch->old_name, &buf))
2022                                 return error("read of %s failed", patch->old_name);
2023                 }
2024         }
2025
2026         if (apply_fragments(&buf, patch) < 0)
2027                 return -1; /* note with --reject this succeeds. */
2028         patch->result = strbuf_detach(&buf, &patch->resultsize);
2029
2030         if (0 < patch->is_delete && patch->resultsize)
2031                 return error("removal patch leaves file contents");
2032
2033         return 0;
2034 }
2035
2036 static int check_to_create_blob(const char *new_name, int ok_if_exists)
2037 {
2038         struct stat nst;
2039         if (!lstat(new_name, &nst)) {
2040                 if (S_ISDIR(nst.st_mode) || ok_if_exists)
2041                         return 0;
2042                 /*
2043                  * A leading component of new_name might be a symlink
2044                  * that is going to be removed with this patch, but
2045                  * still pointing at somewhere that has the path.
2046                  * In such a case, path "new_name" does not exist as
2047                  * far as git is concerned.
2048                  */
2049                 if (has_symlink_leading_path(new_name, NULL))
2050                         return 0;
2051
2052                 return error("%s: already exists in working directory", new_name);
2053         }
2054         else if ((errno != ENOENT) && (errno != ENOTDIR))
2055                 return error("%s: %s", new_name, strerror(errno));
2056         return 0;
2057 }
2058
2059 static int verify_index_match(struct cache_entry *ce, struct stat *st)
2060 {
2061         if (S_ISGITLINK(ntohl(ce->ce_mode))) {
2062                 if (!S_ISDIR(st->st_mode))
2063                         return -1;
2064                 return 0;
2065         }
2066         return ce_match_stat(ce, st, CE_MATCH_IGNORE_VALID);
2067 }
2068
2069 static int check_patch(struct patch *patch, struct patch *prev_patch)
2070 {
2071         struct stat st;
2072         const char *old_name = patch->old_name;
2073         const char *new_name = patch->new_name;
2074         const char *name = old_name ? old_name : new_name;
2075         struct cache_entry *ce = NULL;
2076         int ok_if_exists;
2077
2078         patch->rejected = 1; /* we will drop this after we succeed */
2079
2080         /*
2081          * Make sure that we do not have local modifications from the
2082          * index when we are looking at the index.  Also make sure
2083          * we have the preimage file to be patched in the work tree,
2084          * unless --cached, which tells git to apply only in the index.
2085          */
2086         if (old_name) {
2087                 int stat_ret = 0;
2088                 unsigned st_mode = 0;
2089
2090                 if (!cached)
2091                         stat_ret = lstat(old_name, &st);
2092                 if (check_index) {
2093                         int pos = cache_name_pos(old_name, strlen(old_name));
2094                         if (pos < 0)
2095                                 return error("%s: does not exist in index",
2096                                              old_name);
2097                         ce = active_cache[pos];
2098                         if (stat_ret < 0) {
2099                                 struct checkout costate;
2100                                 if (errno != ENOENT)
2101                                         return error("%s: %s", old_name,
2102                                                      strerror(errno));
2103                                 /* checkout */
2104                                 costate.base_dir = "";
2105                                 costate.base_dir_len = 0;
2106                                 costate.force = 0;
2107                                 costate.quiet = 0;
2108                                 costate.not_new = 0;
2109                                 costate.refresh_cache = 1;
2110                                 if (checkout_entry(ce,
2111                                                    &costate,
2112                                                    NULL) ||
2113                                     lstat(old_name, &st))
2114                                         return -1;
2115                         }
2116                         if (!cached && verify_index_match(ce, &st))
2117                                 return error("%s: does not match index",
2118                                              old_name);
2119                         if (cached)
2120                                 st_mode = ntohl(ce->ce_mode);
2121                 } else if (stat_ret < 0)
2122                         return error("%s: %s", old_name, strerror(errno));
2123
2124                 if (!cached)
2125                         st_mode = ntohl(ce_mode_from_stat(ce, st.st_mode));
2126
2127                 if (patch->is_new < 0)
2128                         patch->is_new = 0;
2129                 if (!patch->old_mode)
2130                         patch->old_mode = st_mode;
2131                 if ((st_mode ^ patch->old_mode) & S_IFMT)
2132                         return error("%s: wrong type", old_name);
2133                 if (st_mode != patch->old_mode)
2134                         fprintf(stderr, "warning: %s has type %o, expected %o\n",
2135                                 old_name, st_mode, patch->old_mode);
2136         }
2137
2138         if (new_name && prev_patch && 0 < prev_patch->is_delete &&
2139             !strcmp(prev_patch->old_name, new_name))
2140                 /*
2141                  * A type-change diff is always split into a patch to
2142                  * delete old, immediately followed by a patch to
2143                  * create new (see diff.c::run_diff()); in such a case
2144                  * it is Ok that the entry to be deleted by the
2145                  * previous patch is still in the working tree and in
2146                  * the index.
2147                  */
2148                 ok_if_exists = 1;
2149         else
2150                 ok_if_exists = 0;
2151
2152         if (new_name &&
2153             ((0 < patch->is_new) | (0 < patch->is_rename) | patch->is_copy)) {
2154                 if (check_index &&
2155                     cache_name_pos(new_name, strlen(new_name)) >= 0 &&
2156                     !ok_if_exists)
2157                         return error("%s: already exists in index", new_name);
2158                 if (!cached) {
2159                         int err = check_to_create_blob(new_name, ok_if_exists);
2160                         if (err)
2161                                 return err;
2162                 }
2163                 if (!patch->new_mode) {
2164                         if (0 < patch->is_new)
2165                                 patch->new_mode = S_IFREG | 0644;
2166                         else
2167                                 patch->new_mode = patch->old_mode;
2168                 }
2169         }
2170
2171         if (new_name && old_name) {
2172                 int same = !strcmp(old_name, new_name);
2173                 if (!patch->new_mode)
2174                         patch->new_mode = patch->old_mode;
2175                 if ((patch->old_mode ^ patch->new_mode) & S_IFMT)
2176                         return error("new mode (%o) of %s does not match old mode (%o)%s%s",
2177                                 patch->new_mode, new_name, patch->old_mode,
2178                                 same ? "" : " of ", same ? "" : old_name);
2179         }
2180
2181         if (apply_data(patch, &st, ce) < 0)
2182                 return error("%s: patch does not apply", name);
2183         patch->rejected = 0;
2184         return 0;
2185 }
2186
2187 static int check_patch_list(struct patch *patch)
2188 {
2189         struct patch *prev_patch = NULL;
2190         int err = 0;
2191
2192         for (prev_patch = NULL; patch ; patch = patch->next) {
2193                 if (apply_verbosely)
2194                         say_patch_name(stderr,
2195                                        "Checking patch ", patch, "...\n");
2196                 err |= check_patch(patch, prev_patch);
2197                 prev_patch = patch;
2198         }
2199         return err;
2200 }
2201
2202 /* This function tries to read the sha1 from the current index */
2203 static int get_current_sha1(const char *path, unsigned char *sha1)
2204 {
2205         int pos;
2206
2207         if (read_cache() < 0)
2208                 return -1;
2209         pos = cache_name_pos(path, strlen(path));
2210         if (pos < 0)
2211                 return -1;
2212         hashcpy(sha1, active_cache[pos]->sha1);
2213         return 0;
2214 }
2215
2216 /* Build an index that contains the just the files needed for a 3way merge */
2217 static void build_fake_ancestor(struct patch *list, const char *filename)
2218 {
2219         struct patch *patch;
2220         struct index_state result = { 0 };
2221         int fd;
2222
2223         /* Once we start supporting the reverse patch, it may be
2224          * worth showing the new sha1 prefix, but until then...
2225          */
2226         for (patch = list; patch; patch = patch->next) {
2227                 const unsigned char *sha1_ptr;
2228                 unsigned char sha1[20];
2229                 struct cache_entry *ce;
2230                 const char *name;
2231
2232                 name = patch->old_name ? patch->old_name : patch->new_name;
2233                 if (0 < patch->is_new)
2234                         continue;
2235                 else if (get_sha1(patch->old_sha1_prefix, sha1))
2236                         /* git diff has no index line for mode/type changes */
2237                         if (!patch->lines_added && !patch->lines_deleted) {
2238                                 if (get_current_sha1(patch->new_name, sha1) ||
2239                                     get_current_sha1(patch->old_name, sha1))
2240                                         die("mode change for %s, which is not "
2241                                                 "in current HEAD", name);
2242                                 sha1_ptr = sha1;
2243                         } else
2244                                 die("sha1 information is lacking or useless "
2245                                         "(%s).", name);
2246                 else
2247                         sha1_ptr = sha1;
2248
2249                 ce = make_cache_entry(patch->old_mode, sha1_ptr, name, 0, 0);
2250                 if (add_index_entry(&result, ce, ADD_CACHE_OK_TO_ADD))
2251                         die ("Could not add %s to temporary index", name);
2252         }
2253
2254         fd = open(filename, O_WRONLY | O_CREAT, 0666);
2255         if (fd < 0 || write_index(&result, fd) || close(fd))
2256                 die ("Could not write temporary index to %s", filename);
2257
2258         discard_index(&result);
2259 }
2260
2261 static void stat_patch_list(struct patch *patch)
2262 {
2263         int files, adds, dels;
2264
2265         for (files = adds = dels = 0 ; patch ; patch = patch->next) {
2266                 files++;
2267                 adds += patch->lines_added;
2268                 dels += patch->lines_deleted;
2269                 show_stats(patch);
2270         }
2271
2272         printf(" %d files changed, %d insertions(+), %d deletions(-)\n", files, adds, dels);
2273 }
2274
2275 static void numstat_patch_list(struct patch *patch)
2276 {
2277         for ( ; patch; patch = patch->next) {
2278                 const char *name;
2279                 name = patch->new_name ? patch->new_name : patch->old_name;
2280                 if (patch->is_binary)
2281                         printf("-\t-\t");
2282                 else
2283                         printf("%d\t%d\t", patch->lines_added, patch->lines_deleted);
2284                 write_name_quoted(name, stdout, line_termination);
2285         }
2286 }
2287
2288 static void show_file_mode_name(const char *newdelete, unsigned int mode, const char *name)
2289 {
2290         if (mode)
2291                 printf(" %s mode %06o %s\n", newdelete, mode, name);
2292         else
2293                 printf(" %s %s\n", newdelete, name);
2294 }
2295
2296 static void show_mode_change(struct patch *p, int show_name)
2297 {
2298         if (p->old_mode && p->new_mode && p->old_mode != p->new_mode) {
2299                 if (show_name)
2300                         printf(" mode change %06o => %06o %s\n",
2301                                p->old_mode, p->new_mode, p->new_name);
2302                 else
2303                         printf(" mode change %06o => %06o\n",
2304                                p->old_mode, p->new_mode);
2305         }
2306 }
2307
2308 static void show_rename_copy(struct patch *p)
2309 {
2310         const char *renamecopy = p->is_rename ? "rename" : "copy";
2311         const char *old, *new;
2312
2313         /* Find common prefix */
2314         old = p->old_name;
2315         new = p->new_name;
2316         while (1) {
2317                 const char *slash_old, *slash_new;
2318                 slash_old = strchr(old, '/');
2319                 slash_new = strchr(new, '/');
2320                 if (!slash_old ||
2321                     !slash_new ||
2322                     slash_old - old != slash_new - new ||
2323                     memcmp(old, new, slash_new - new))
2324                         break;
2325                 old = slash_old + 1;
2326                 new = slash_new + 1;
2327         }
2328         /* p->old_name thru old is the common prefix, and old and new
2329          * through the end of names are renames
2330          */
2331         if (old != p->old_name)
2332                 printf(" %s %.*s{%s => %s} (%d%%)\n", renamecopy,
2333                        (int)(old - p->old_name), p->old_name,
2334                        old, new, p->score);
2335         else
2336                 printf(" %s %s => %s (%d%%)\n", renamecopy,
2337                        p->old_name, p->new_name, p->score);
2338         show_mode_change(p, 0);
2339 }
2340
2341 static void summary_patch_list(struct patch *patch)
2342 {
2343         struct patch *p;
2344
2345         for (p = patch; p; p = p->next) {
2346                 if (p->is_new)
2347                         show_file_mode_name("create", p->new_mode, p->new_name);
2348                 else if (p->is_delete)
2349                         show_file_mode_name("delete", p->old_mode, p->old_name);
2350                 else {
2351                         if (p->is_rename || p->is_copy)
2352                                 show_rename_copy(p);
2353                         else {
2354                                 if (p->score) {
2355                                         printf(" rewrite %s (%d%%)\n",
2356                                                p->new_name, p->score);
2357                                         show_mode_change(p, 0);
2358                                 }
2359                                 else
2360                                         show_mode_change(p, 1);
2361                         }
2362                 }
2363         }
2364 }
2365
2366 static void patch_stats(struct patch *patch)
2367 {
2368         int lines = patch->lines_added + patch->lines_deleted;
2369
2370         if (lines > max_change)
2371                 max_change = lines;
2372         if (patch->old_name) {
2373                 int len = quote_c_style(patch->old_name, NULL, NULL, 0);
2374                 if (!len)
2375                         len = strlen(patch->old_name);
2376                 if (len > max_len)
2377                         max_len = len;
2378         }
2379         if (patch->new_name) {
2380                 int len = quote_c_style(patch->new_name, NULL, NULL, 0);
2381                 if (!len)
2382                         len = strlen(patch->new_name);
2383                 if (len > max_len)
2384                         max_len = len;
2385         }
2386 }
2387
2388 static void remove_file(struct patch *patch, int rmdir_empty)
2389 {
2390         if (update_index) {
2391                 if (remove_file_from_cache(patch->old_name) < 0)
2392                         die("unable to remove %s from index", patch->old_name);
2393         }
2394         if (!cached) {
2395                 if (S_ISGITLINK(patch->old_mode)) {
2396                         if (rmdir(patch->old_name))
2397                                 warning("unable to remove submodule %s",
2398                                         patch->old_name);
2399                 } else if (!unlink(patch->old_name) && rmdir_empty) {
2400                         char *name = xstrdup(patch->old_name);
2401                         char *end = strrchr(name, '/');
2402                         while (end) {
2403                                 *end = 0;
2404                                 if (rmdir(name))
2405                                         break;
2406                                 end = strrchr(name, '/');
2407                         }
2408                         free(name);
2409                 }
2410         }
2411 }
2412
2413 static void add_index_file(const char *path, unsigned mode, void *buf, unsigned long size)
2414 {
2415         struct stat st;
2416         struct cache_entry *ce;
2417         int namelen = strlen(path);
2418         unsigned ce_size = cache_entry_size(namelen);
2419
2420         if (!update_index)
2421                 return;
2422
2423         ce = xcalloc(1, ce_size);
2424         memcpy(ce->name, path, namelen);
2425         ce->ce_mode = create_ce_mode(mode);
2426         ce->ce_flags = htons(namelen);
2427         if (S_ISGITLINK(mode)) {
2428                 const char *s = buf;
2429
2430                 if (get_sha1_hex(s + strlen("Subproject commit "), ce->sha1))
2431                         die("corrupt patch for subproject %s", path);
2432         } else {
2433                 if (!cached) {
2434                         if (lstat(path, &st) < 0)
2435                                 die("unable to stat newly created file %s",
2436                                     path);
2437                         fill_stat_cache_info(ce, &st);
2438                 }
2439                 if (write_sha1_file(buf, size, blob_type, ce->sha1) < 0)
2440                         die("unable to create backing store for newly created file %s", path);
2441         }
2442         if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) < 0)
2443                 die("unable to add cache entry for %s", path);
2444 }
2445
2446 static int try_create_file(const char *path, unsigned int mode, const char *buf, unsigned long size)
2447 {
2448         int fd;
2449         struct strbuf nbuf;
2450
2451         if (S_ISGITLINK(mode)) {
2452                 struct stat st;
2453                 if (!lstat(path, &st) && S_ISDIR(st.st_mode))
2454                         return 0;
2455                 return mkdir(path, 0777);
2456         }
2457
2458         if (has_symlinks && S_ISLNK(mode))
2459                 /* Although buf:size is counted string, it also is NUL
2460                  * terminated.
2461                  */
2462                 return symlink(buf, path);
2463
2464         fd = open(path, O_CREAT | O_EXCL | O_WRONLY, (mode & 0100) ? 0777 : 0666);
2465         if (fd < 0)
2466                 return -1;
2467
2468         strbuf_init(&nbuf, 0);
2469         if (convert_to_working_tree(path, buf, size, &nbuf)) {
2470                 size = nbuf.len;
2471                 buf  = nbuf.buf;
2472         }
2473         write_or_die(fd, buf, size);
2474         strbuf_release(&nbuf);
2475
2476         if (close(fd) < 0)
2477                 die("closing file %s: %s", path, strerror(errno));
2478         return 0;
2479 }
2480
2481 /*
2482  * We optimistically assume that the directories exist,
2483  * which is true 99% of the time anyway. If they don't,
2484  * we create them and try again.
2485  */
2486 static void create_one_file(char *path, unsigned mode, const char *buf, unsigned long size)
2487 {
2488         if (cached)
2489                 return;
2490         if (!try_create_file(path, mode, buf, size))
2491                 return;
2492
2493         if (errno == ENOENT) {
2494                 if (safe_create_leading_directories(path))
2495                         return;
2496                 if (!try_create_file(path, mode, buf, size))
2497                         return;
2498         }
2499
2500         if (errno == EEXIST || errno == EACCES) {
2501                 /* We may be trying to create a file where a directory
2502                  * used to be.
2503                  */
2504                 struct stat st;
2505                 if (!lstat(path, &st) && (!S_ISDIR(st.st_mode) || !rmdir(path)))
2506                         errno = EEXIST;
2507         }
2508
2509         if (errno == EEXIST) {
2510                 unsigned int nr = getpid();
2511
2512                 for (;;) {
2513                         const char *newpath;
2514                         newpath = mkpath("%s~%u", path, nr);
2515                         if (!try_create_file(newpath, mode, buf, size)) {
2516                                 if (!rename(newpath, path))
2517                                         return;
2518                                 unlink(newpath);
2519                                 break;
2520                         }
2521                         if (errno != EEXIST)
2522                                 break;
2523                         ++nr;
2524                 }
2525         }
2526         die("unable to write file %s mode %o", path, mode);
2527 }
2528
2529 static void create_file(struct patch *patch)
2530 {
2531         char *path = patch->new_name;
2532         unsigned mode = patch->new_mode;
2533         unsigned long size = patch->resultsize;
2534         char *buf = patch->result;
2535
2536         if (!mode)
2537                 mode = S_IFREG | 0644;
2538         create_one_file(path, mode, buf, size);
2539         add_index_file(path, mode, buf, size);
2540 }
2541
2542 /* phase zero is to remove, phase one is to create */
2543 static void write_out_one_result(struct patch *patch, int phase)
2544 {
2545         if (patch->is_delete > 0) {
2546                 if (phase == 0)
2547                         remove_file(patch, 1);
2548                 return;
2549         }
2550         if (patch->is_new > 0 || patch->is_copy) {
2551                 if (phase == 1)
2552                         create_file(patch);
2553                 return;
2554         }
2555         /*
2556          * Rename or modification boils down to the same
2557          * thing: remove the old, write the new
2558          */
2559         if (phase == 0)
2560                 remove_file(patch, patch->is_rename);
2561         if (phase == 1)
2562                 create_file(patch);
2563 }
2564
2565 static int write_out_one_reject(struct patch *patch)
2566 {
2567         FILE *rej;
2568         char namebuf[PATH_MAX];
2569         struct fragment *frag;
2570         int cnt = 0;
2571
2572         for (cnt = 0, frag = patch->fragments; frag; frag = frag->next) {
2573                 if (!frag->rejected)
2574                         continue;
2575                 cnt++;
2576         }
2577
2578         if (!cnt) {
2579                 if (apply_verbosely)
2580                         say_patch_name(stderr,
2581                                        "Applied patch ", patch, " cleanly.\n");
2582                 return 0;
2583         }
2584
2585         /* This should not happen, because a removal patch that leaves
2586          * contents are marked "rejected" at the patch level.
2587          */
2588         if (!patch->new_name)
2589                 die("internal error");
2590
2591         /* Say this even without --verbose */
2592         say_patch_name(stderr, "Applying patch ", patch, " with");
2593         fprintf(stderr, " %d rejects...\n", cnt);
2594
2595         cnt = strlen(patch->new_name);
2596         if (ARRAY_SIZE(namebuf) <= cnt + 5) {
2597                 cnt = ARRAY_SIZE(namebuf) - 5;
2598                 fprintf(stderr,
2599                         "warning: truncating .rej filename to %.*s.rej",
2600                         cnt - 1, patch->new_name);
2601         }
2602         memcpy(namebuf, patch->new_name, cnt);
2603         memcpy(namebuf + cnt, ".rej", 5);
2604
2605         rej = fopen(namebuf, "w");
2606         if (!rej)
2607                 return error("cannot open %s: %s", namebuf, strerror(errno));
2608
2609         /* Normal git tools never deal with .rej, so do not pretend
2610          * this is a git patch by saying --git nor give extended
2611          * headers.  While at it, maybe please "kompare" that wants
2612          * the trailing TAB and some garbage at the end of line ;-).
2613          */
2614         fprintf(rej, "diff a/%s b/%s\t(rejected hunks)\n",
2615                 patch->new_name, patch->new_name);
2616         for (cnt = 1, frag = patch->fragments;
2617              frag;
2618              cnt++, frag = frag->next) {
2619                 if (!frag->rejected) {
2620                         fprintf(stderr, "Hunk #%d applied cleanly.\n", cnt);
2621                         continue;
2622                 }
2623                 fprintf(stderr, "Rejected hunk #%d.\n", cnt);
2624                 fprintf(rej, "%.*s", frag->size, frag->patch);
2625                 if (frag->patch[frag->size-1] != '\n')
2626                         fputc('\n', rej);
2627         }
2628         fclose(rej);
2629         return -1;
2630 }
2631
2632 static int write_out_results(struct patch *list, int skipped_patch)
2633 {
2634         int phase;
2635         int errs = 0;
2636         struct patch *l;
2637
2638         if (!list && !skipped_patch)
2639                 return error("No changes");
2640
2641         for (phase = 0; phase < 2; phase++) {
2642                 l = list;
2643                 while (l) {
2644                         if (l->rejected)
2645                                 errs = 1;
2646                         else {
2647                                 write_out_one_result(l, phase);
2648                                 if (phase == 1 && write_out_one_reject(l))
2649                                         errs = 1;
2650                         }
2651                         l = l->next;
2652                 }
2653         }
2654         return errs;
2655 }
2656
2657 static struct lock_file lock_file;
2658
2659 static struct excludes {
2660         struct excludes *next;
2661         const char *path;
2662 } *excludes;
2663
2664 static int use_patch(struct patch *p)
2665 {
2666         const char *pathname = p->new_name ? p->new_name : p->old_name;
2667         struct excludes *x = excludes;
2668         while (x) {
2669                 if (fnmatch(x->path, pathname, 0) == 0)
2670                         return 0;
2671                 x = x->next;
2672         }
2673         if (0 < prefix_length) {
2674                 int pathlen = strlen(pathname);
2675                 if (pathlen <= prefix_length ||
2676                     memcmp(prefix, pathname, prefix_length))
2677                         return 0;
2678         }
2679         return 1;
2680 }
2681
2682 static void prefix_one(char **name)
2683 {
2684         char *old_name = *name;
2685         if (!old_name)
2686                 return;
2687         *name = xstrdup(prefix_filename(prefix, prefix_length, *name));
2688         free(old_name);
2689 }
2690
2691 static void prefix_patches(struct patch *p)
2692 {
2693         if (!prefix || p->is_toplevel_relative)
2694                 return;
2695         for ( ; p; p = p->next) {
2696                 if (p->new_name == p->old_name) {
2697                         char *prefixed = p->new_name;
2698                         prefix_one(&prefixed);
2699                         p->new_name = p->old_name = prefixed;
2700                 }
2701                 else {
2702                         prefix_one(&p->new_name);
2703                         prefix_one(&p->old_name);
2704                 }
2705         }
2706 }
2707
2708 static int apply_patch(int fd, const char *filename, int inaccurate_eof)
2709 {
2710         size_t offset;
2711         struct strbuf buf;
2712         struct patch *list = NULL, **listp = &list;
2713         int skipped_patch = 0;
2714
2715         strbuf_init(&buf, 0);
2716         patch_input_file = filename;
2717         read_patch_file(&buf, fd);
2718         offset = 0;
2719         while (offset < buf.len) {
2720                 struct patch *patch;
2721                 int nr;
2722
2723                 patch = xcalloc(1, sizeof(*patch));
2724                 patch->inaccurate_eof = inaccurate_eof;
2725                 nr = parse_chunk(buf.buf + offset, buf.len - offset, patch);
2726                 if (nr < 0)
2727                         break;
2728                 if (apply_in_reverse)
2729                         reverse_patches(patch);
2730                 if (prefix)
2731                         prefix_patches(patch);
2732                 if (use_patch(patch)) {
2733                         patch_stats(patch);
2734                         *listp = patch;
2735                         listp = &patch->next;
2736                 }
2737                 else {
2738                         /* perhaps free it a bit better? */
2739                         free(patch);
2740                         skipped_patch++;
2741                 }
2742                 offset += nr;
2743         }
2744
2745         if (whitespace_error && (ws_error_action == die_on_ws_error))
2746                 apply = 0;
2747
2748         update_index = check_index && apply;
2749         if (update_index && newfd < 0)
2750                 newfd = hold_locked_index(&lock_file, 1);
2751
2752         if (check_index) {
2753                 if (read_cache() < 0)
2754                         die("unable to read index file");
2755         }
2756
2757         if ((check || apply) &&
2758             check_patch_list(list) < 0 &&
2759             !apply_with_reject)
2760                 exit(1);
2761
2762         if (apply && write_out_results(list, skipped_patch))
2763                 exit(1);
2764
2765         if (fake_ancestor)
2766                 build_fake_ancestor(list, fake_ancestor);
2767
2768         if (diffstat)
2769                 stat_patch_list(list);
2770
2771         if (numstat)
2772                 numstat_patch_list(list);
2773
2774         if (summary)
2775                 summary_patch_list(list);
2776
2777         strbuf_release(&buf);
2778         return 0;
2779 }
2780
2781 static int git_apply_config(const char *var, const char *value)
2782 {
2783         if (!strcmp(var, "apply.whitespace")) {
2784                 apply_default_whitespace = xstrdup(value);
2785                 return 0;
2786         }
2787         return git_default_config(var, value);
2788 }
2789
2790
2791 int cmd_apply(int argc, const char **argv, const char *unused_prefix)
2792 {
2793         int i;
2794         int read_stdin = 1;
2795         int inaccurate_eof = 0;
2796         int errs = 0;
2797         int is_not_gitdir = 0;
2798
2799         const char *whitespace_option = NULL;
2800
2801         prefix = setup_git_directory_gently(&is_not_gitdir);
2802         prefix_length = prefix ? strlen(prefix) : 0;
2803         git_config(git_apply_config);
2804         if (apply_default_whitespace)
2805                 parse_whitespace_option(apply_default_whitespace);
2806
2807         for (i = 1; i < argc; i++) {
2808                 const char *arg = argv[i];
2809                 char *end;
2810                 int fd;
2811
2812                 if (!strcmp(arg, "-")) {
2813                         errs |= apply_patch(0, "<stdin>", inaccurate_eof);
2814                         read_stdin = 0;
2815                         continue;
2816                 }
2817                 if (!prefixcmp(arg, "--exclude=")) {
2818                         struct excludes *x = xmalloc(sizeof(*x));
2819                         x->path = arg + 10;
2820                         x->next = excludes;
2821                         excludes = x;
2822                         continue;
2823                 }
2824                 if (!prefixcmp(arg, "-p")) {
2825                         p_value = atoi(arg + 2);
2826                         p_value_known = 1;
2827                         continue;
2828                 }
2829                 if (!strcmp(arg, "--no-add")) {
2830                         no_add = 1;
2831                         continue;
2832                 }
2833                 if (!strcmp(arg, "--stat")) {
2834                         apply = 0;
2835                         diffstat = 1;
2836                         continue;
2837                 }
2838                 if (!strcmp(arg, "--allow-binary-replacement") ||
2839                     !strcmp(arg, "--binary")) {
2840                         continue; /* now no-op */
2841                 }
2842                 if (!strcmp(arg, "--numstat")) {
2843                         apply = 0;
2844                         numstat = 1;
2845                         continue;
2846                 }
2847                 if (!strcmp(arg, "--summary")) {
2848                         apply = 0;
2849                         summary = 1;
2850                         continue;
2851                 }
2852                 if (!strcmp(arg, "--check")) {
2853                         apply = 0;
2854                         check = 1;
2855                         continue;
2856                 }
2857                 if (!strcmp(arg, "--index")) {
2858                         if (is_not_gitdir)
2859                                 die("--index outside a repository");
2860                         check_index = 1;
2861                         continue;
2862                 }
2863                 if (!strcmp(arg, "--cached")) {
2864                         if (is_not_gitdir)
2865                                 die("--cached outside a repository");
2866                         check_index = 1;
2867                         cached = 1;
2868                         continue;
2869                 }
2870                 if (!strcmp(arg, "--apply")) {
2871                         apply = 1;
2872                         continue;
2873                 }
2874                 if (!strcmp(arg, "--build-fake-ancestor")) {
2875                         apply = 0;
2876                         if (++i >= argc)
2877                                 die ("need a filename");
2878                         fake_ancestor = argv[i];
2879                         continue;
2880                 }
2881                 if (!strcmp(arg, "-z")) {
2882                         line_termination = 0;
2883                         continue;
2884                 }
2885                 if (!prefixcmp(arg, "-C")) {
2886                         p_context = strtoul(arg + 2, &end, 0);
2887                         if (*end != '\0')
2888                                 die("unrecognized context count '%s'", arg + 2);
2889                         continue;
2890                 }
2891                 if (!prefixcmp(arg, "--whitespace=")) {
2892                         whitespace_option = arg + 13;
2893                         parse_whitespace_option(arg + 13);
2894                         continue;
2895                 }
2896                 if (!strcmp(arg, "-R") || !strcmp(arg, "--reverse")) {
2897                         apply_in_reverse = 1;
2898                         continue;
2899                 }
2900                 if (!strcmp(arg, "--unidiff-zero")) {
2901                         unidiff_zero = 1;
2902                         continue;
2903                 }
2904                 if (!strcmp(arg, "--reject")) {
2905                         apply = apply_with_reject = apply_verbosely = 1;
2906                         continue;
2907                 }
2908                 if (!strcmp(arg, "-v") || !strcmp(arg, "--verbose")) {
2909                         apply_verbosely = 1;
2910                         continue;
2911                 }
2912                 if (!strcmp(arg, "--inaccurate-eof")) {
2913                         inaccurate_eof = 1;
2914                         continue;
2915                 }
2916                 if (0 < prefix_length)
2917                         arg = prefix_filename(prefix, prefix_length, arg);
2918
2919                 fd = open(arg, O_RDONLY);
2920                 if (fd < 0)
2921                         usage(apply_usage);
2922                 read_stdin = 0;
2923                 set_default_whitespace_mode(whitespace_option);
2924                 errs |= apply_patch(fd, arg, inaccurate_eof);
2925                 close(fd);
2926         }
2927         set_default_whitespace_mode(whitespace_option);
2928         if (read_stdin)
2929                 errs |= apply_patch(0, "<stdin>", inaccurate_eof);
2930         if (whitespace_error) {
2931                 if (squelch_whitespace_errors &&
2932                     squelch_whitespace_errors < whitespace_error) {
2933                         int squelched =
2934                                 whitespace_error - squelch_whitespace_errors;
2935                         fprintf(stderr, "warning: squelched %d "
2936                                 "whitespace error%s\n",
2937                                 squelched,
2938                                 squelched == 1 ? "" : "s");
2939                 }
2940                 if (ws_error_action == die_on_ws_error)
2941                         die("%d line%s add%s whitespace errors.",
2942                             whitespace_error,
2943                             whitespace_error == 1 ? "" : "s",
2944                             whitespace_error == 1 ? "s" : "");
2945                 if (applied_after_fixing_ws)
2946                         fprintf(stderr, "warning: %d line%s applied after"
2947                                 " fixing whitespace errors.\n",
2948                                 applied_after_fixing_ws,
2949                                 applied_after_fixing_ws == 1 ? "" : "s");
2950                 else if (whitespace_error)
2951                         fprintf(stderr, "warning: %d line%s add%s whitespace errors.\n",
2952                                 whitespace_error,
2953                                 whitespace_error == 1 ? "" : "s",
2954                                 whitespace_error == 1 ? "s" : "");
2955         }
2956
2957         if (update_index) {
2958                 if (write_cache(newfd, active_cache, active_nr) ||
2959                     close(newfd) || commit_locked_index(&lock_file))
2960                         die("Unable to write new index file");
2961         }
2962
2963         return !!errs;
2964 }