GIT 0.99.9a
[git] / 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 <fnmatch.h>
10 #include "cache.h"
11 #include "quote.h"
12
13 //  --check turns on checking that the working tree matches the
14 //    files that are being modified, but doesn't apply the patch
15 //  --stat does just a diffstat, and doesn't actually apply
16 //  --numstat does numeric diffstat, and doesn't actually apply
17 //  --index-info shows the old and new index info for paths if available.
18 //
19 static int check_index = 0;
20 static int write_index = 0;
21 static int diffstat = 0;
22 static int numstat = 0;
23 static int summary = 0;
24 static int check = 0;
25 static int apply = 1;
26 static int show_index_info = 0;
27 static int line_termination = '\n';
28 static const char apply_usage[] =
29 "git-apply [--stat] [--numstat] [--summary] [--check] [--index] [--apply] [--index-info] [-z] <patch>...";
30
31 /*
32  * For "diff-stat" like behaviour, we keep track of the biggest change
33  * we've seen, and the longest filename. That allows us to do simple
34  * scaling.
35  */
36 static int max_change, max_len;
37
38 /*
39  * Various "current state", notably line numbers and what
40  * file (and how) we're patching right now.. The "is_xxxx"
41  * things are flags, where -1 means "don't know yet".
42  */
43 static int linenr = 1;
44
45 struct fragment {
46         unsigned long oldpos, oldlines;
47         unsigned long newpos, newlines;
48         const char *patch;
49         int size;
50         struct fragment *next;
51 };
52
53 struct patch {
54         char *new_name, *old_name, *def_name;
55         unsigned int old_mode, new_mode;
56         int is_rename, is_copy, is_new, is_delete;
57         int lines_added, lines_deleted;
58         int score;
59         struct fragment *fragments;
60         char *result;
61         unsigned long resultsize;
62         char old_sha1_prefix[41];
63         char new_sha1_prefix[41];
64         struct patch *next;
65 };
66
67 #define CHUNKSIZE (8192)
68 #define SLOP (16)
69
70 static void *read_patch_file(int fd, unsigned long *sizep)
71 {
72         unsigned long size = 0, alloc = CHUNKSIZE;
73         void *buffer = xmalloc(alloc);
74
75         for (;;) {
76                 int nr = alloc - size;
77                 if (nr < 1024) {
78                         alloc += CHUNKSIZE;
79                         buffer = xrealloc(buffer, alloc);
80                         nr = alloc - size;
81                 }
82                 nr = read(fd, buffer + size, nr);
83                 if (!nr)
84                         break;
85                 if (nr < 0) {
86                         if (errno == EAGAIN)
87                                 continue;
88                         die("git-apply: read returned %s", strerror(errno));
89                 }
90                 size += nr;
91         }
92         *sizep = size;
93
94         /*
95          * Make sure that we have some slop in the buffer
96          * so that we can do speculative "memcmp" etc, and
97          * see to it that it is NUL-filled.
98          */
99         if (alloc < size + SLOP)
100                 buffer = xrealloc(buffer, size + SLOP);
101         memset(buffer + size, 0, SLOP);
102         return buffer;
103 }
104
105 static unsigned long linelen(const char *buffer, unsigned long size)
106 {
107         unsigned long len = 0;
108         while (size--) {
109                 len++;
110                 if (*buffer++ == '\n')
111                         break;
112         }
113         return len;
114 }
115
116 static int is_dev_null(const char *str)
117 {
118         return !memcmp("/dev/null", str, 9) && isspace(str[9]);
119 }
120
121 #define TERM_SPACE      1
122 #define TERM_TAB        2
123
124 static int name_terminate(const char *name, int namelen, int c, int terminate)
125 {
126         if (c == ' ' && !(terminate & TERM_SPACE))
127                 return 0;
128         if (c == '\t' && !(terminate & TERM_TAB))
129                 return 0;
130
131         return 1;
132 }
133
134 static char * find_name(const char *line, char *def, int p_value, int terminate)
135 {
136         int len;
137         const char *start = line;
138         char *name;
139
140         if (*line == '"') {
141                 /* Proposed "new-style" GNU patch/diff format; see
142                  * http://marc.theaimsgroup.com/?l=git&m=112927316408690&w=2
143                  */
144                 name = unquote_c_style(line, NULL);
145                 if (name) {
146                         char *cp = name;
147                         while (p_value) {
148                                 cp = strchr(name, '/');
149                                 if (!cp)
150                                         break;
151                                 cp++;
152                                 p_value--;
153                         }
154                         if (cp) {
155                                 /* name can later be freed, so we need
156                                  * to memmove, not just return cp
157                                  */
158                                 memmove(name, cp, strlen(cp) + 1);
159                                 free(def);
160                                 return name;
161                         }
162                         else {
163                                 free(name);
164                                 name = NULL;
165                         }
166                 }
167         }
168
169         for (;;) {
170                 char c = *line;
171
172                 if (isspace(c)) {
173                         if (c == '\n')
174                                 break;
175                         if (name_terminate(start, line-start, c, terminate))
176                                 break;
177                 }
178                 line++;
179                 if (c == '/' && !--p_value)
180                         start = line;
181         }
182         if (!start)
183                 return def;
184         len = line - start;
185         if (!len)
186                 return def;
187
188         /*
189          * Generally we prefer the shorter name, especially
190          * if the other one is just a variation of that with
191          * something else tacked on to the end (ie "file.orig"
192          * or "file~").
193          */
194         if (def) {
195                 int deflen = strlen(def);
196                 if (deflen < len && !strncmp(start, def, deflen))
197                         return def;
198         }
199
200         name = xmalloc(len + 1);
201         memcpy(name, start, len);
202         name[len] = 0;
203         free(def);
204         return name;
205 }
206
207 /*
208  * Get the name etc info from the --/+++ lines of a traditional patch header
209  *
210  * NOTE! This hardcodes "-p1" behaviour in filename detection.
211  *
212  * FIXME! The end-of-filename heuristics are kind of screwy. For existing
213  * files, we can happily check the index for a match, but for creating a
214  * new file we should try to match whatever "patch" does. I have no idea.
215  */
216 static void parse_traditional_patch(const char *first, const char *second, struct patch *patch)
217 {
218         int p_value = 1;
219         char *name;
220
221         first += 4;     // skip "--- "
222         second += 4;    // skip "+++ "
223         if (is_dev_null(first)) {
224                 patch->is_new = 1;
225                 patch->is_delete = 0;
226                 name = find_name(second, NULL, p_value, TERM_SPACE | TERM_TAB);
227                 patch->new_name = name;
228         } else if (is_dev_null(second)) {
229                 patch->is_new = 0;
230                 patch->is_delete = 1;
231                 name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);
232                 patch->old_name = name;
233         } else {
234                 name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);
235                 name = find_name(second, name, p_value, TERM_SPACE | TERM_TAB);
236                 patch->old_name = patch->new_name = name;
237         }
238         if (!name)
239                 die("unable to find filename in patch at line %d", linenr);
240 }
241
242 static int gitdiff_hdrend(const char *line, struct patch *patch)
243 {
244         return -1;
245 }
246
247 /*
248  * We're anal about diff header consistency, to make
249  * sure that we don't end up having strange ambiguous
250  * patches floating around.
251  *
252  * As a result, gitdiff_{old|new}name() will check
253  * their names against any previous information, just
254  * to make sure..
255  */
256 static char *gitdiff_verify_name(const char *line, int isnull, char *orig_name, const char *oldnew)
257 {
258         if (!orig_name && !isnull)
259                 return find_name(line, NULL, 1, 0);
260
261         if (orig_name) {
262                 int len;
263                 const char *name;
264                 char *another;
265                 name = orig_name;
266                 len = strlen(name);
267                 if (isnull)
268                         die("git-apply: bad git-diff - expected /dev/null, got %s on line %d", name, linenr);
269                 another = find_name(line, NULL, 1, 0);
270                 if (!another || memcmp(another, name, len))
271                         die("git-apply: bad git-diff - inconsistent %s filename on line %d", oldnew, linenr);
272                 free(another);
273                 return orig_name;
274         }
275         else {
276                 /* expect "/dev/null" */
277                 if (memcmp("/dev/null", line, 9) || line[9] != '\n')
278                         die("git-apply: bad git-diff - expected /dev/null on line %d", linenr);
279                 return NULL;
280         }
281 }
282
283 static int gitdiff_oldname(const char *line, struct patch *patch)
284 {
285         patch->old_name = gitdiff_verify_name(line, patch->is_new, patch->old_name, "old");
286         return 0;
287 }
288
289 static int gitdiff_newname(const char *line, struct patch *patch)
290 {
291         patch->new_name = gitdiff_verify_name(line, patch->is_delete, patch->new_name, "new");
292         return 0;
293 }
294
295 static int gitdiff_oldmode(const char *line, struct patch *patch)
296 {
297         patch->old_mode = strtoul(line, NULL, 8);
298         return 0;
299 }
300
301 static int gitdiff_newmode(const char *line, struct patch *patch)
302 {
303         patch->new_mode = strtoul(line, NULL, 8);
304         return 0;
305 }
306
307 static int gitdiff_delete(const char *line, struct patch *patch)
308 {
309         patch->is_delete = 1;
310         patch->old_name = patch->def_name;
311         return gitdiff_oldmode(line, patch);
312 }
313
314 static int gitdiff_newfile(const char *line, struct patch *patch)
315 {
316         patch->is_new = 1;
317         patch->new_name = patch->def_name;
318         return gitdiff_newmode(line, patch);
319 }
320
321 static int gitdiff_copysrc(const char *line, struct patch *patch)
322 {
323         patch->is_copy = 1;
324         patch->old_name = find_name(line, NULL, 0, 0);
325         return 0;
326 }
327
328 static int gitdiff_copydst(const char *line, struct patch *patch)
329 {
330         patch->is_copy = 1;
331         patch->new_name = find_name(line, NULL, 0, 0);
332         return 0;
333 }
334
335 static int gitdiff_renamesrc(const char *line, struct patch *patch)
336 {
337         patch->is_rename = 1;
338         patch->old_name = find_name(line, NULL, 0, 0);
339         return 0;
340 }
341
342 static int gitdiff_renamedst(const char *line, struct patch *patch)
343 {
344         patch->is_rename = 1;
345         patch->new_name = find_name(line, NULL, 0, 0);
346         return 0;
347 }
348
349 static int gitdiff_similarity(const char *line, struct patch *patch)
350 {
351         if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)
352                 patch->score = 0;
353         return 0;
354 }
355
356 static int gitdiff_dissimilarity(const char *line, struct patch *patch)
357 {
358         if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)
359                 patch->score = 0;
360         return 0;
361 }
362
363 static int gitdiff_index(const char *line, struct patch *patch)
364 {
365         /* index line is N hexadecimal, "..", N hexadecimal,
366          * and optional space with octal mode.
367          */
368         const char *ptr, *eol;
369         int len;
370
371         ptr = strchr(line, '.');
372         if (!ptr || ptr[1] != '.' || 40 <= ptr - line)
373                 return 0;
374         len = ptr - line;
375         memcpy(patch->old_sha1_prefix, line, len);
376         patch->old_sha1_prefix[len] = 0;
377
378         line = ptr + 2;
379         ptr = strchr(line, ' ');
380         eol = strchr(line, '\n');
381
382         if (!ptr || eol < ptr)
383                 ptr = eol;
384         len = ptr - line;
385
386         if (40 <= len)
387                 return 0;
388         memcpy(patch->new_sha1_prefix, line, len);
389         patch->new_sha1_prefix[len] = 0;
390         if (*ptr == ' ')
391                 patch->new_mode = patch->old_mode = strtoul(ptr+1, NULL, 8);
392         return 0;
393 }
394
395 /*
396  * This is normal for a diff that doesn't change anything: we'll fall through
397  * into the next diff. Tell the parser to break out.
398  */
399 static int gitdiff_unrecognized(const char *line, struct patch *patch)
400 {
401         return -1;
402 }
403
404 static const char *stop_at_slash(const char *line, int llen)
405 {
406         int i;
407
408         for (i = 0; i < llen; i++) {
409                 int ch = line[i];
410                 if (ch == '/')
411                         return line + i;
412         }
413         return NULL;
414 }
415
416 /* This is to extract the same name that appears on "diff --git"
417  * line.  We do not find and return anything if it is a rename
418  * patch, and it is OK because we will find the name elsewhere.
419  * We need to reliably find name only when it is mode-change only,
420  * creation or deletion of an empty file.  In any of these cases,
421  * both sides are the same name under a/ and b/ respectively.
422  */
423 static char *git_header_name(char *line, int llen)
424 {
425         int len;
426         const char *name;
427         const char *second = NULL;
428
429         line += strlen("diff --git ");
430         llen -= strlen("diff --git ");
431
432         if (*line == '"') {
433                 const char *cp;
434                 char *first = unquote_c_style(line, &second);
435                 if (!first)
436                         return NULL;
437
438                 /* advance to the first slash */
439                 cp = stop_at_slash(first, strlen(first));
440                 if (!cp || cp == first) {
441                         /* we do not accept absolute paths */
442                 free_first_and_fail:
443                         free(first);
444                         return NULL;
445                 }
446                 len = strlen(cp+1);
447                 memmove(first, cp+1, len+1); /* including NUL */
448
449                 /* second points at one past closing dq of name.
450                  * find the second name.
451                  */
452                 while ((second < line + llen) && isspace(*second))
453                         second++;
454
455                 if (line + llen <= second)
456                         goto free_first_and_fail;
457                 if (*second == '"') {
458                         char *sp = unquote_c_style(second, NULL);
459                         if (!sp)
460                                 goto free_first_and_fail;
461                         cp = stop_at_slash(sp, strlen(sp));
462                         if (!cp || cp == sp) {
463                         free_both_and_fail:
464                                 free(sp);
465                                 goto free_first_and_fail;
466                         }
467                         /* They must match, otherwise ignore */
468                         if (strcmp(cp+1, first))
469                                 goto free_both_and_fail;
470                         free(sp);
471                         return first;
472                 }
473
474                 /* unquoted second */
475                 cp = stop_at_slash(second, line + llen - second);
476                 if (!cp || cp == second)
477                         goto free_first_and_fail;
478                 cp++;
479                 if (line + llen - cp != len + 1 ||
480                     memcmp(first, cp, len))
481                         goto free_first_and_fail;
482                 return first;
483         }
484
485         /* unquoted first name */
486         name = stop_at_slash(line, llen);
487         if (!name || name == line)
488                 return NULL;
489
490         name++;
491
492         /* since the first name is unquoted, a dq if exists must be
493          * the beginning of the second name.
494          */
495         for (second = name; second < line + llen; second++) {
496                 if (*second == '"') {
497                         const char *cp = second;
498                         const char *np;
499                         char *sp = unquote_c_style(second, NULL);
500
501                         if (!sp)
502                                 return NULL;
503                         np = stop_at_slash(sp, strlen(sp));
504                         if (!np || np == sp) {
505                         free_second_and_fail:
506                                 free(sp);
507                                 return NULL;
508                         }
509                         np++;
510                         len = strlen(np);
511                         if (len < cp - name &&
512                             !strncmp(np, name, len) &&
513                             isspace(name[len])) {
514                                 /* Good */
515                                 memmove(sp, np, len + 1);
516                                 return sp;
517                         }
518                         goto free_second_and_fail;
519                 }
520         }
521
522         /*
523          * Accept a name only if it shows up twice, exactly the same
524          * form.
525          */
526         for (len = 0 ; ; len++) {
527                 char c = name[len];
528
529                 switch (c) {
530                 default:
531                         continue;
532                 case '\n':
533                         return NULL;
534                 case '\t': case ' ':
535                         second = name+len;
536                         for (;;) {
537                                 char c = *second++;
538                                 if (c == '\n')
539                                         return NULL;
540                                 if (c == '/')
541                                         break;
542                         }
543                         if (second[len] == '\n' && !memcmp(name, second, len)) {
544                                 char *ret = xmalloc(len + 1);
545                                 memcpy(ret, name, len);
546                                 ret[len] = 0;
547                                 return ret;
548                         }
549                 }
550         }
551         return NULL;
552 }
553
554 /* Verify that we recognize the lines following a git header */
555 static int parse_git_header(char *line, int len, unsigned int size, struct patch *patch)
556 {
557         unsigned long offset;
558
559         /* A git diff has explicit new/delete information, so we don't guess */
560         patch->is_new = 0;
561         patch->is_delete = 0;
562
563         /*
564          * Some things may not have the old name in the
565          * rest of the headers anywhere (pure mode changes,
566          * or removing or adding empty files), so we get
567          * the default name from the header.
568          */
569         patch->def_name = git_header_name(line, len);
570
571         line += len;
572         size -= len;
573         linenr++;
574         for (offset = len ; size > 0 ; offset += len, size -= len, line += len, linenr++) {
575                 static const struct opentry {
576                         const char *str;
577                         int (*fn)(const char *, struct patch *);
578                 } optable[] = {
579                         { "@@ -", gitdiff_hdrend },
580                         { "--- ", gitdiff_oldname },
581                         { "+++ ", gitdiff_newname },
582                         { "old mode ", gitdiff_oldmode },
583                         { "new mode ", gitdiff_newmode },
584                         { "deleted file mode ", gitdiff_delete },
585                         { "new file mode ", gitdiff_newfile },
586                         { "copy from ", gitdiff_copysrc },
587                         { "copy to ", gitdiff_copydst },
588                         { "rename old ", gitdiff_renamesrc },
589                         { "rename new ", gitdiff_renamedst },
590                         { "rename from ", gitdiff_renamesrc },
591                         { "rename to ", gitdiff_renamedst },
592                         { "similarity index ", gitdiff_similarity },
593                         { "dissimilarity index ", gitdiff_dissimilarity },
594                         { "index ", gitdiff_index },
595                         { "", gitdiff_unrecognized },
596                 };
597                 int i;
598
599                 len = linelen(line, size);
600                 if (!len || line[len-1] != '\n')
601                         break;
602                 for (i = 0; i < sizeof(optable) / sizeof(optable[0]); i++) {
603                         const struct opentry *p = optable + i;
604                         int oplen = strlen(p->str);
605                         if (len < oplen || memcmp(p->str, line, oplen))
606                                 continue;
607                         if (p->fn(line + oplen, patch) < 0)
608                                 return offset;
609                         break;
610                 }
611         }
612
613         return offset;
614 }
615
616 static int parse_num(const char *line, unsigned long *p)
617 {
618         char *ptr;
619
620         if (!isdigit(*line))
621                 return 0;
622         *p = strtoul(line, &ptr, 10);
623         return ptr - line;
624 }
625
626 static int parse_range(const char *line, int len, int offset, const char *expect,
627                         unsigned long *p1, unsigned long *p2)
628 {
629         int digits, ex;
630
631         if (offset < 0 || offset >= len)
632                 return -1;
633         line += offset;
634         len -= offset;
635
636         digits = parse_num(line, p1);
637         if (!digits)
638                 return -1;
639
640         offset += digits;
641         line += digits;
642         len -= digits;
643
644         *p2 = *p1;
645         if (*line == ',') {
646                 digits = parse_num(line+1, p2);
647                 if (!digits)
648                         return -1;
649
650                 offset += digits+1;
651                 line += digits+1;
652                 len -= digits+1;
653         }
654
655         ex = strlen(expect);
656         if (ex > len)
657                 return -1;
658         if (memcmp(line, expect, ex))
659                 return -1;
660
661         return offset + ex;
662 }
663
664 /*
665  * Parse a unified diff fragment header of the
666  * form "@@ -a,b +c,d @@"
667  */
668 static int parse_fragment_header(char *line, int len, struct fragment *fragment)
669 {
670         int offset;
671
672         if (!len || line[len-1] != '\n')
673                 return -1;
674
675         /* Figure out the number of lines in a fragment */
676         offset = parse_range(line, len, 4, " +", &fragment->oldpos, &fragment->oldlines);
677         offset = parse_range(line, len, offset, " @@", &fragment->newpos, &fragment->newlines);
678
679         return offset;
680 }
681
682 static int find_header(char *line, unsigned long size, int *hdrsize, struct patch *patch)
683 {
684         unsigned long offset, len;
685
686         patch->is_rename = patch->is_copy = 0;
687         patch->is_new = patch->is_delete = -1;
688         patch->old_mode = patch->new_mode = 0;
689         patch->old_name = patch->new_name = NULL;
690         for (offset = 0; size > 0; offset += len, size -= len, line += len, linenr++) {
691                 unsigned long nextlen;
692
693                 len = linelen(line, size);
694                 if (!len)
695                         break;
696
697                 /* Testing this early allows us to take a few shortcuts.. */
698                 if (len < 6)
699                         continue;
700
701                 /*
702                  * Make sure we don't find any unconnected patch fragmants.
703                  * That's a sign that we didn't find a header, and that a
704                  * patch has become corrupted/broken up.
705                  */
706                 if (!memcmp("@@ -", line, 4)) {
707                         struct fragment dummy;
708                         if (parse_fragment_header(line, len, &dummy) < 0)
709                                 continue;
710                         error("patch fragment without header at line %d: %.*s", linenr, (int)len-1, line);
711                 }
712
713                 if (size < len + 6)
714                         break;
715
716                 /*
717                  * Git patch? It might not have a real patch, just a rename
718                  * or mode change, so we handle that specially
719                  */
720                 if (!memcmp("diff --git ", line, 11)) {
721                         int git_hdr_len = parse_git_header(line, len, size, patch);
722                         if (git_hdr_len <= len)
723                                 continue;
724                         if (!patch->old_name && !patch->new_name) {
725                                 if (!patch->def_name)
726                                         die("git diff header lacks filename information (line %d)", linenr);
727                                 patch->old_name = patch->new_name = patch->def_name;
728                         }
729                         *hdrsize = git_hdr_len;
730                         return offset;
731                 }
732
733                 /** --- followed by +++ ? */
734                 if (memcmp("--- ", line,  4) || memcmp("+++ ", line + len, 4))
735                         continue;
736
737                 /*
738                  * We only accept unified patches, so we want it to
739                  * at least have "@@ -a,b +c,d @@\n", which is 14 chars
740                  * minimum
741                  */
742                 nextlen = linelen(line + len, size - len);
743                 if (size < nextlen + 14 || memcmp("@@ -", line + len + nextlen, 4))
744                         continue;
745
746                 /* Ok, we'll consider it a patch */
747                 parse_traditional_patch(line, line+len, patch);
748                 *hdrsize = len + nextlen;
749                 linenr += 2;
750                 return offset;
751         }
752         return -1;
753 }
754
755 /*
756  * Parse a unified diff. Note that this really needs
757  * to parse each fragment separately, since the only
758  * way to know the difference between a "---" that is
759  * part of a patch, and a "---" that starts the next
760  * patch is to look at the line counts..
761  */
762 static int parse_fragment(char *line, unsigned long size, struct patch *patch, struct fragment *fragment)
763 {
764         int added, deleted;
765         int len = linelen(line, size), offset;
766         unsigned long oldlines, newlines;
767
768         offset = parse_fragment_header(line, len, fragment);
769         if (offset < 0)
770                 return -1;
771         oldlines = fragment->oldlines;
772         newlines = fragment->newlines;
773
774         if (patch->is_new < 0) {
775                 patch->is_new =  !oldlines;
776                 if (!oldlines)
777                         patch->old_name = NULL;
778         }
779         if (patch->is_delete < 0) {
780                 patch->is_delete = !newlines;
781                 if (!newlines)
782                         patch->new_name = NULL;
783         }
784
785         if (patch->is_new != !oldlines)
786                 return error("new file depends on old contents");
787         if (patch->is_delete != !newlines) {
788                 if (newlines)
789                         return error("deleted file still has contents");
790                 fprintf(stderr, "** warning: file %s becomes empty but is not deleted\n", patch->new_name);
791         }
792
793         /* Parse the thing.. */
794         line += len;
795         size -= len;
796         linenr++;
797         added = deleted = 0;
798         for (offset = len; size > 0; offset += len, size -= len, line += len, linenr++) {
799                 if (!oldlines && !newlines)
800                         break;
801                 len = linelen(line, size);
802                 if (!len || line[len-1] != '\n')
803                         return -1;
804                 switch (*line) {
805                 default:
806                         return -1;
807                 case ' ':
808                         oldlines--;
809                         newlines--;
810                         break;
811                 case '-':
812                         deleted++;
813                         oldlines--;
814                         break;
815                 case '+':
816                         added++;
817                         newlines--;
818                         break;
819
820                 /* We allow "\ No newline at end of file". Depending
821                  * on locale settings when the patch was produced we
822                  * don't know what this line looks like. The only
823                  * thing we do know is that it begins with "\ ".
824                  * Checking for 12 is just for sanity check -- any
825                  * l10n of "\ No newline..." is at least that long.
826                  */
827                 case '\\':
828                         if (len < 12 || memcmp(line, "\\ ", 2))
829                                 return -1;
830                         break;
831                 }
832         }
833         /* If a fragment ends with an incomplete line, we failed to include
834          * it in the above loop because we hit oldlines == newlines == 0
835          * before seeing it.
836          */
837         if (12 < size && !memcmp(line, "\\ ", 2))
838                 offset += linelen(line, size);
839
840         patch->lines_added += added;
841         patch->lines_deleted += deleted;
842         return offset;
843 }
844
845 static int parse_single_patch(char *line, unsigned long size, struct patch *patch)
846 {
847         unsigned long offset = 0;
848         struct fragment **fragp = &patch->fragments;
849
850         while (size > 4 && !memcmp(line, "@@ -", 4)) {
851                 struct fragment *fragment;
852                 int len;
853
854                 fragment = xmalloc(sizeof(*fragment));
855                 memset(fragment, 0, sizeof(*fragment));
856                 len = parse_fragment(line, size, patch, fragment);
857                 if (len <= 0)
858                         die("corrupt patch at line %d", linenr);
859
860                 fragment->patch = line;
861                 fragment->size = len;
862
863                 *fragp = fragment;
864                 fragp = &fragment->next;
865
866                 offset += len;
867                 line += len;
868                 size -= len;
869         }
870         return offset;
871 }
872
873 static inline int metadata_changes(struct patch *patch)
874 {
875         return  patch->is_rename > 0 ||
876                 patch->is_copy > 0 ||
877                 patch->is_new > 0 ||
878                 patch->is_delete ||
879                 (patch->old_mode && patch->new_mode &&
880                  patch->old_mode != patch->new_mode);
881 }
882
883 static int parse_chunk(char *buffer, unsigned long size, struct patch *patch)
884 {
885         int hdrsize, patchsize;
886         int offset = find_header(buffer, size, &hdrsize, patch);
887
888         if (offset < 0)
889                 return offset;
890
891         patchsize = parse_single_patch(buffer + offset + hdrsize, size - offset - hdrsize, patch);
892
893         if (!patchsize && !metadata_changes(patch))
894                 die("patch with only garbage at line %d", linenr);
895
896         return offset + hdrsize + patchsize;
897 }
898
899 static const char pluses[] = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
900 static const char minuses[]= "----------------------------------------------------------------------";
901
902 static void show_stats(struct patch *patch)
903 {
904         const char *prefix = "";
905         char *name = patch->new_name;
906         char *qname = NULL;
907         int len, max, add, del, total;
908
909         if (!name)
910                 name = patch->old_name;
911
912         if (0 < (len = quote_c_style(name, NULL, NULL, 0))) {
913                 qname = xmalloc(len + 1);
914                 quote_c_style(name, qname, NULL, 0);
915                 name = qname;
916         }
917
918         /*
919          * "scale" the filename
920          */
921         len = strlen(name);
922         max = max_len;
923         if (max > 50)
924                 max = 50;
925         if (len > max) {
926                 char *slash;
927                 prefix = "...";
928                 max -= 3;
929                 name += len - max;
930                 slash = strchr(name, '/');
931                 if (slash)
932                         name = slash;
933         }
934         len = max;
935
936         /*
937          * scale the add/delete
938          */
939         max = max_change;
940         if (max + len > 70)
941                 max = 70 - len;
942
943         add = patch->lines_added;
944         del = patch->lines_deleted;
945         total = add + del;
946
947         if (max_change > 0) {
948                 total = (total * max + max_change / 2) / max_change;
949                 add = (add * max + max_change / 2) / max_change;
950                 del = total - add;
951         }
952         printf(" %s%-*s |%5d %.*s%.*s\n", prefix,
953                 len, name, patch->lines_added + patch->lines_deleted,
954                 add, pluses, del, minuses);
955         if (qname)
956                 free(qname);
957 }
958
959 static int read_old_data(struct stat *st, const char *path, void *buf, unsigned long size)
960 {
961         int fd;
962         unsigned long got;
963
964         switch (st->st_mode & S_IFMT) {
965         case S_IFLNK:
966                 return readlink(path, buf, size);
967         case S_IFREG:
968                 fd = open(path, O_RDONLY);
969                 if (fd < 0)
970                         return error("unable to open %s", path);
971                 got = 0;
972                 for (;;) {
973                         int ret = read(fd, buf + got, size - got);
974                         if (ret < 0) {
975                                 if (errno == EAGAIN)
976                                         continue;
977                                 break;
978                         }
979                         if (!ret)
980                                 break;
981                         got += ret;
982                 }
983                 close(fd);
984                 return got;
985
986         default:
987                 return -1;
988         }
989 }
990
991 static int find_offset(const char *buf, unsigned long size, const char *fragment, unsigned long fragsize, int line)
992 {
993         int i;
994         unsigned long start, backwards, forwards;
995
996         if (fragsize > size)
997                 return -1;
998
999         start = 0;
1000         if (line > 1) {
1001                 unsigned long offset = 0;
1002                 i = line-1;
1003                 while (offset + fragsize <= size) {
1004                         if (buf[offset++] == '\n') {
1005                                 start = offset;
1006                                 if (!--i)
1007                                         break;
1008                         }
1009                 }
1010         }
1011
1012         /* Exact line number? */
1013         if (!memcmp(buf + start, fragment, fragsize))
1014                 return start;
1015
1016         /*
1017          * There's probably some smart way to do this, but I'll leave
1018          * that to the smart and beautiful people. I'm simple and stupid.
1019          */
1020         backwards = start;
1021         forwards = start;
1022         for (i = 0; ; i++) {
1023                 unsigned long try;
1024                 int n;
1025
1026                 /* "backward" */
1027                 if (i & 1) {
1028                         if (!backwards) {
1029                                 if (forwards + fragsize > size)
1030                                         break;
1031                                 continue;
1032                         }
1033                         do {
1034                                 --backwards;
1035                         } while (backwards && buf[backwards-1] != '\n');
1036                         try = backwards;
1037                 } else {
1038                         while (forwards + fragsize <= size) {
1039                                 if (buf[forwards++] == '\n')
1040                                         break;
1041                         }
1042                         try = forwards;
1043                 }
1044
1045                 if (try + fragsize > size)
1046                         continue;
1047                 if (memcmp(buf + try, fragment, fragsize))
1048                         continue;
1049                 n = (i >> 1)+1;
1050                 if (i & 1)
1051                         n = -n;
1052                 return try;
1053         }
1054
1055         /*
1056          * We should start searching forward and backward.
1057          */
1058         return -1;
1059 }
1060
1061 struct buffer_desc {
1062         char *buffer;
1063         unsigned long size;
1064         unsigned long alloc;
1065 };
1066
1067 static int apply_one_fragment(struct buffer_desc *desc, struct fragment *frag)
1068 {
1069         char *buf = desc->buffer;
1070         const char *patch = frag->patch;
1071         int offset, size = frag->size;
1072         char *old = xmalloc(size);
1073         char *new = xmalloc(size);
1074         int oldsize = 0, newsize = 0;
1075
1076         while (size > 0) {
1077                 int len = linelen(patch, size);
1078                 int plen;
1079
1080                 if (!len)
1081                         break;
1082
1083                 /*
1084                  * "plen" is how much of the line we should use for
1085                  * the actual patch data. Normally we just remove the
1086                  * first character on the line, but if the line is
1087                  * followed by "\ No newline", then we also remove the
1088                  * last one (which is the newline, of course).
1089                  */
1090                 plen = len-1;
1091                 if (len < size && patch[len] == '\\')
1092                         plen--;
1093                 switch (*patch) {
1094                 case ' ':
1095                 case '-':
1096                         memcpy(old + oldsize, patch + 1, plen);
1097                         oldsize += plen;
1098                         if (*patch == '-')
1099                                 break;
1100                 /* Fall-through for ' ' */
1101                 case '+':
1102                         memcpy(new + newsize, patch + 1, plen);
1103                         newsize += plen;
1104                         break;
1105                 case '@': case '\\':
1106                         /* Ignore it, we already handled it */
1107                         break;
1108                 default:
1109                         return -1;
1110                 }
1111                 patch += len;
1112                 size -= len;
1113         }
1114
1115         offset = find_offset(buf, desc->size, old, oldsize, frag->newpos);
1116         if (offset >= 0) {
1117                 int diff = newsize - oldsize;
1118                 unsigned long size = desc->size + diff;
1119                 unsigned long alloc = desc->alloc;
1120
1121                 if (size > alloc) {
1122                         alloc = size + 8192;
1123                         desc->alloc = alloc;
1124                         buf = xrealloc(buf, alloc);
1125                         desc->buffer = buf;
1126                 }
1127                 desc->size = size;
1128                 memmove(buf + offset + newsize, buf + offset + oldsize, size - offset - newsize);
1129                 memcpy(buf + offset, new, newsize);
1130                 offset = 0;
1131         }
1132
1133         free(old);
1134         free(new);
1135         return offset;
1136 }
1137
1138 static int apply_fragments(struct buffer_desc *desc, struct patch *patch)
1139 {
1140         struct fragment *frag = patch->fragments;
1141
1142         while (frag) {
1143                 if (apply_one_fragment(desc, frag) < 0)
1144                         return error("patch failed: %s:%ld", patch->old_name, frag->oldpos);
1145                 frag = frag->next;
1146         }
1147         return 0;
1148 }
1149
1150 static int apply_data(struct patch *patch, struct stat *st)
1151 {
1152         char *buf;
1153         unsigned long size, alloc;
1154         struct buffer_desc desc;
1155
1156         size = 0;
1157         alloc = 0;
1158         buf = NULL;
1159         if (patch->old_name) {
1160                 size = st->st_size;
1161                 alloc = size + 8192;
1162                 buf = xmalloc(alloc);
1163                 if (read_old_data(st, patch->old_name, buf, alloc) != size)
1164                         return error("read of %s failed", patch->old_name);
1165         }
1166
1167         desc.size = size;
1168         desc.alloc = alloc;
1169         desc.buffer = buf;
1170         if (apply_fragments(&desc, patch) < 0)
1171                 return -1;
1172         patch->result = desc.buffer;
1173         patch->resultsize = desc.size;
1174
1175         if (patch->is_delete && patch->resultsize)
1176                 return error("removal patch leaves file contents");
1177
1178         return 0;
1179 }
1180
1181 static int check_patch(struct patch *patch)
1182 {
1183         struct stat st;
1184         const char *old_name = patch->old_name;
1185         const char *new_name = patch->new_name;
1186
1187         if (old_name) {
1188                 int changed;
1189                 int stat_ret = lstat(old_name, &st);
1190
1191                 if (check_index) {
1192                         int pos = cache_name_pos(old_name, strlen(old_name));
1193                         if (pos < 0)
1194                                 return error("%s: does not exist in index",
1195                                              old_name);
1196                         if (stat_ret < 0) {
1197                                 struct checkout costate;
1198                                 if (errno != ENOENT)
1199                                         return error("%s: %s", old_name,
1200                                                      strerror(errno));
1201                                 /* checkout */
1202                                 costate.base_dir = "";
1203                                 costate.base_dir_len = 0;
1204                                 costate.force = 0;
1205                                 costate.quiet = 0;
1206                                 costate.not_new = 0;
1207                                 costate.refresh_cache = 1;
1208                                 if (checkout_entry(active_cache[pos],
1209                                                    &costate) ||
1210                                     lstat(old_name, &st))
1211                                         return -1;
1212                         }
1213
1214                         changed = ce_match_stat(active_cache[pos], &st);
1215                         if (changed)
1216                                 return error("%s: does not match index",
1217                                              old_name);
1218                 }
1219                 else if (stat_ret < 0)
1220                         return error("%s: %s", old_name, strerror(errno));
1221
1222                 if (patch->is_new < 0)
1223                         patch->is_new = 0;
1224                 st.st_mode = ntohl(create_ce_mode(st.st_mode));
1225                 if (!patch->old_mode)
1226                         patch->old_mode = st.st_mode;
1227                 if ((st.st_mode ^ patch->old_mode) & S_IFMT)
1228                         return error("%s: wrong type", old_name);
1229                 if (st.st_mode != patch->old_mode)
1230                         fprintf(stderr, "warning: %s has type %o, expected %o\n",
1231                                 old_name, st.st_mode, patch->old_mode);
1232         }
1233
1234         if (new_name && (patch->is_new | patch->is_rename | patch->is_copy)) {
1235                 if (check_index && cache_name_pos(new_name, strlen(new_name)) >= 0)
1236                         return error("%s: already exists in index", new_name);
1237                 if (!lstat(new_name, &st))
1238                         return error("%s: already exists in working directory", new_name);
1239                 if (errno != ENOENT)
1240                         return error("%s: %s", new_name, strerror(errno));
1241                 if (!patch->new_mode) {
1242                         if (patch->is_new)
1243                                 patch->new_mode = S_IFREG | 0644;
1244                         else
1245                                 patch->new_mode = patch->old_mode;
1246                 }
1247         }
1248
1249         if (new_name && old_name) {
1250                 int same = !strcmp(old_name, new_name);
1251                 if (!patch->new_mode)
1252                         patch->new_mode = patch->old_mode;
1253                 if ((patch->old_mode ^ patch->new_mode) & S_IFMT)
1254                         return error("new mode (%o) of %s does not match old mode (%o)%s%s",
1255                                 patch->new_mode, new_name, patch->old_mode,
1256                                 same ? "" : " of ", same ? "" : old_name);
1257         }       
1258
1259         if (apply_data(patch, &st) < 0)
1260                 return error("%s: patch does not apply", old_name);
1261         return 0;
1262 }
1263
1264 static int check_patch_list(struct patch *patch)
1265 {
1266         int error = 0;
1267
1268         for (;patch ; patch = patch->next)
1269                 error |= check_patch(patch);
1270         return error;
1271 }
1272
1273 static inline int is_null_sha1(const unsigned char *sha1)
1274 {
1275         return !memcmp(sha1, null_sha1, 20);
1276 }
1277
1278 static void show_index_list(struct patch *list)
1279 {
1280         struct patch *patch;
1281
1282         /* Once we start supporting the reverse patch, it may be
1283          * worth showing the new sha1 prefix, but until then...
1284          */
1285         for (patch = list; patch; patch = patch->next) {
1286                 const unsigned char *sha1_ptr;
1287                 unsigned char sha1[20];
1288                 const char *name;
1289
1290                 name = patch->old_name ? patch->old_name : patch->new_name;
1291                 if (patch->is_new)
1292                         sha1_ptr = null_sha1;
1293                 else if (get_sha1(patch->old_sha1_prefix, sha1))
1294                         die("sha1 information is lacking or useless (%s).",
1295                             name);
1296                 else
1297                         sha1_ptr = sha1;
1298
1299                 printf("%06o %s ",patch->old_mode, sha1_to_hex(sha1_ptr));
1300                 if (line_termination && quote_c_style(name, NULL, NULL, 0))
1301                         quote_c_style(name, NULL, stdout, 0);
1302                 else
1303                         fputs(name, stdout);
1304                 putchar(line_termination);
1305         }
1306 }
1307
1308 static void stat_patch_list(struct patch *patch)
1309 {
1310         int files, adds, dels;
1311
1312         for (files = adds = dels = 0 ; patch ; patch = patch->next) {
1313                 files++;
1314                 adds += patch->lines_added;
1315                 dels += patch->lines_deleted;
1316                 show_stats(patch);
1317         }
1318
1319         printf(" %d files changed, %d insertions(+), %d deletions(-)\n", files, adds, dels);
1320 }
1321
1322 static void numstat_patch_list(struct patch *patch)
1323 {
1324         for ( ; patch; patch = patch->next) {
1325                 const char *name;
1326                 name = patch->old_name ? patch->old_name : patch->new_name;
1327                 printf("%d\t%d\t", patch->lines_added, patch->lines_deleted);
1328                 if (line_termination && quote_c_style(name, NULL, NULL, 0))
1329                         quote_c_style(name, NULL, stdout, 0);
1330                 else
1331                         fputs(name, stdout);
1332                 putchar('\n');
1333         }
1334 }
1335
1336 static void show_file_mode_name(const char *newdelete, unsigned int mode, const char *name)
1337 {
1338         if (mode)
1339                 printf(" %s mode %06o %s\n", newdelete, mode, name);
1340         else
1341                 printf(" %s %s\n", newdelete, name);
1342 }
1343
1344 static void show_mode_change(struct patch *p, int show_name)
1345 {
1346         if (p->old_mode && p->new_mode && p->old_mode != p->new_mode) {
1347                 if (show_name)
1348                         printf(" mode change %06o => %06o %s\n",
1349                                p->old_mode, p->new_mode, p->new_name);
1350                 else
1351                         printf(" mode change %06o => %06o\n",
1352                                p->old_mode, p->new_mode);
1353         }
1354 }
1355
1356 static void show_rename_copy(struct patch *p)
1357 {
1358         const char *renamecopy = p->is_rename ? "rename" : "copy";
1359         const char *old, *new;
1360
1361         /* Find common prefix */
1362         old = p->old_name;
1363         new = p->new_name;
1364         while (1) {
1365                 const char *slash_old, *slash_new;
1366                 slash_old = strchr(old, '/');
1367                 slash_new = strchr(new, '/');
1368                 if (!slash_old ||
1369                     !slash_new ||
1370                     slash_old - old != slash_new - new ||
1371                     memcmp(old, new, slash_new - new))
1372                         break;
1373                 old = slash_old + 1;
1374                 new = slash_new + 1;
1375         }
1376         /* p->old_name thru old is the common prefix, and old and new
1377          * through the end of names are renames
1378          */
1379         if (old != p->old_name)
1380                 printf(" %s %.*s{%s => %s} (%d%%)\n", renamecopy,
1381                        (int)(old - p->old_name), p->old_name,
1382                        old, new, p->score);
1383         else
1384                 printf(" %s %s => %s (%d%%)\n", renamecopy,
1385                        p->old_name, p->new_name, p->score);
1386         show_mode_change(p, 0);
1387 }
1388
1389 static void summary_patch_list(struct patch *patch)
1390 {
1391         struct patch *p;
1392
1393         for (p = patch; p; p = p->next) {
1394                 if (p->is_new)
1395                         show_file_mode_name("create", p->new_mode, p->new_name);
1396                 else if (p->is_delete)
1397                         show_file_mode_name("delete", p->old_mode, p->old_name);
1398                 else {
1399                         if (p->is_rename || p->is_copy)
1400                                 show_rename_copy(p);
1401                         else {
1402                                 if (p->score) {
1403                                         printf(" rewrite %s (%d%%)\n",
1404                                                p->new_name, p->score);
1405                                         show_mode_change(p, 0);
1406                                 }
1407                                 else
1408                                         show_mode_change(p, 1);
1409                         }
1410                 }
1411         }
1412 }
1413
1414 static void patch_stats(struct patch *patch)
1415 {
1416         int lines = patch->lines_added + patch->lines_deleted;
1417
1418         if (lines > max_change)
1419                 max_change = lines;
1420         if (patch->old_name) {
1421                 int len = quote_c_style(patch->old_name, NULL, NULL, 0);
1422                 if (!len)
1423                         len = strlen(patch->old_name);
1424                 if (len > max_len)
1425                         max_len = len;
1426         }
1427         if (patch->new_name) {
1428                 int len = quote_c_style(patch->new_name, NULL, NULL, 0);
1429                 if (!len)
1430                         len = strlen(patch->new_name);
1431                 if (len > max_len)
1432                         max_len = len;
1433         }
1434 }
1435
1436 static void remove_file(struct patch *patch)
1437 {
1438         if (write_index) {
1439                 if (remove_file_from_cache(patch->old_name) < 0)
1440                         die("unable to remove %s from index", patch->old_name);
1441         }
1442         unlink(patch->old_name);
1443 }
1444
1445 static void add_index_file(const char *path, unsigned mode, void *buf, unsigned long size)
1446 {
1447         struct stat st;
1448         struct cache_entry *ce;
1449         int namelen = strlen(path);
1450         unsigned ce_size = cache_entry_size(namelen);
1451
1452         if (!write_index)
1453                 return;
1454
1455         ce = xmalloc(ce_size);
1456         memset(ce, 0, ce_size);
1457         memcpy(ce->name, path, namelen);
1458         ce->ce_mode = create_ce_mode(mode);
1459         ce->ce_flags = htons(namelen);
1460         if (lstat(path, &st) < 0)
1461                 die("unable to stat newly created file %s", path);
1462         fill_stat_cache_info(ce, &st);
1463         if (write_sha1_file(buf, size, "blob", ce->sha1) < 0)
1464                 die("unable to create backing store for newly created file %s", path);
1465         if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) < 0)
1466                 die("unable to add cache entry for %s", path);
1467 }
1468
1469 static void create_subdirectories(const char *path)
1470 {
1471         int len = strlen(path);
1472         char *buf = xmalloc(len + 1);
1473         const char *slash = path;
1474
1475         while ((slash = strchr(slash+1, '/')) != NULL) {
1476                 len = slash - path;
1477                 memcpy(buf, path, len);
1478                 buf[len] = 0;
1479                 if (mkdir(buf, 0777) < 0) {
1480                         if (errno != EEXIST)
1481                                 break;
1482                 }
1483         }
1484         free(buf);
1485 }
1486
1487 static int try_create_file(const char *path, unsigned int mode, const char *buf, unsigned long size)
1488 {
1489         int fd;
1490
1491         if (S_ISLNK(mode))
1492                 return symlink(buf, path);
1493         fd = open(path, O_CREAT | O_EXCL | O_WRONLY | O_TRUNC, (mode & 0100) ? 0777 : 0666);
1494         if (fd < 0)
1495                 return -1;
1496         while (size) {
1497                 int written = write(fd, buf, size);
1498                 if (written < 0) {
1499                         if (errno == EINTR || errno == EAGAIN)
1500                                 continue;
1501                         die("writing file %s: %s", path, strerror(errno));
1502                 }
1503                 if (!written)
1504                         die("out of space writing file %s", path);
1505                 buf += written;
1506                 size -= written;
1507         }
1508         if (close(fd) < 0)
1509                 die("closing file %s: %s", path, strerror(errno));
1510         return 0;
1511 }
1512
1513 /*
1514  * We optimistically assume that the directories exist,
1515  * which is true 99% of the time anyway. If they don't,
1516  * we create them and try again.
1517  */
1518 static void create_one_file(const char *path, unsigned mode, const char *buf, unsigned long size)
1519 {
1520         if (!try_create_file(path, mode, buf, size))
1521                 return;
1522
1523         if (errno == ENOENT) {
1524                 create_subdirectories(path);
1525                 if (!try_create_file(path, mode, buf, size))
1526                         return;
1527         }
1528
1529         if (errno == EEXIST) {
1530                 unsigned int nr = getpid();
1531
1532                 for (;;) {
1533                         const char *newpath;
1534                         newpath = mkpath("%s~%u", path, nr);
1535                         if (!try_create_file(newpath, mode, buf, size)) {
1536                                 if (!rename(newpath, path))
1537                                         return;
1538                                 unlink(newpath);
1539                                 break;
1540                         }
1541                         if (errno != EEXIST)
1542                                 break;
1543                 }                       
1544         }
1545         die("unable to write file %s mode %o", path, mode);
1546 }
1547
1548 static void create_file(struct patch *patch)
1549 {
1550         const char *path = patch->new_name;
1551         unsigned mode = patch->new_mode;
1552         unsigned long size = patch->resultsize;
1553         char *buf = patch->result;
1554
1555         if (!mode)
1556                 mode = S_IFREG | 0644;
1557         create_one_file(path, mode, buf, size); 
1558         add_index_file(path, mode, buf, size);
1559 }
1560
1561 static void write_out_one_result(struct patch *patch)
1562 {
1563         if (patch->is_delete > 0) {
1564                 remove_file(patch);
1565                 return;
1566         }
1567         if (patch->is_new > 0 || patch->is_copy) {
1568                 create_file(patch);
1569                 return;
1570         }
1571         /*
1572          * Rename or modification boils down to the same
1573          * thing: remove the old, write the new
1574          */
1575         remove_file(patch);
1576         create_file(patch);
1577 }
1578
1579 static void write_out_results(struct patch *list, int skipped_patch)
1580 {
1581         if (!list && !skipped_patch)
1582                 die("No changes");
1583
1584         while (list) {
1585                 write_out_one_result(list);
1586                 list = list->next;
1587         }
1588 }
1589
1590 static struct cache_file cache_file;
1591
1592 static struct excludes {
1593         struct excludes *next;
1594         const char *path;
1595 } *excludes;
1596
1597 static int use_patch(struct patch *p)
1598 {
1599         const char *pathname = p->new_name ? p->new_name : p->old_name;
1600         struct excludes *x = excludes;
1601         while (x) {
1602                 if (fnmatch(x->path, pathname, 0) == 0)
1603                         return 0;
1604                 x = x->next;
1605         }
1606         return 1;
1607 }
1608
1609 static int apply_patch(int fd)
1610 {
1611         int newfd;
1612         unsigned long offset, size;
1613         char *buffer = read_patch_file(fd, &size);
1614         struct patch *list = NULL, **listp = &list;
1615         int skipped_patch = 0;
1616
1617         if (!buffer)
1618                 return -1;
1619         offset = 0;
1620         while (size > 0) {
1621                 struct patch *patch;
1622                 int nr;
1623
1624                 patch = xmalloc(sizeof(*patch));
1625                 memset(patch, 0, sizeof(*patch));
1626                 nr = parse_chunk(buffer + offset, size, patch);
1627                 if (nr < 0)
1628                         break;
1629                 if (use_patch(patch)) {
1630                         patch_stats(patch);
1631                         *listp = patch;
1632                         listp = &patch->next;
1633                 } else {
1634                         /* perhaps free it a bit better? */
1635                         free(patch);
1636                         skipped_patch++;
1637                 }
1638                 offset += nr;
1639                 size -= nr;
1640         }
1641
1642         newfd = -1;
1643         write_index = check_index && apply;
1644         if (write_index)
1645                 newfd = hold_index_file_for_update(&cache_file, get_index_file());
1646         if (check_index) {
1647                 if (read_cache() < 0)
1648                         die("unable to read index file");
1649         }
1650
1651         if ((check || apply) && check_patch_list(list) < 0)
1652                 exit(1);
1653
1654         if (apply)
1655                 write_out_results(list, skipped_patch);
1656
1657         if (write_index) {
1658                 if (write_cache(newfd, active_cache, active_nr) ||
1659                     commit_index_file(&cache_file))
1660                         die("Unable to write new cachefile");
1661         }
1662
1663         if (show_index_info)
1664                 show_index_list(list);
1665
1666         if (diffstat)
1667                 stat_patch_list(list);
1668
1669         if (numstat)
1670                 numstat_patch_list(list);
1671
1672         if (summary)
1673                 summary_patch_list(list);
1674
1675         free(buffer);
1676         return 0;
1677 }
1678
1679 int main(int argc, char **argv)
1680 {
1681         int i;
1682         int read_stdin = 1;
1683
1684         for (i = 1; i < argc; i++) {
1685                 const char *arg = argv[i];
1686                 int fd;
1687
1688                 if (!strcmp(arg, "-")) {
1689                         apply_patch(0);
1690                         read_stdin = 0;
1691                         continue;
1692                 }
1693                 if (!strncmp(arg, "--exclude=", 10)) {
1694                         struct excludes *x = xmalloc(sizeof(*x));
1695                         x->path = arg + 10;
1696                         x->next = excludes;
1697                         excludes = x;
1698                         continue;
1699                 }
1700                 if (!strcmp(arg, "--stat")) {
1701                         apply = 0;
1702                         diffstat = 1;
1703                         continue;
1704                 }
1705                 if (!strcmp(arg, "--numstat")) {
1706                         apply = 0;
1707                         numstat = 1;
1708                         continue;
1709                 }
1710                 if (!strcmp(arg, "--summary")) {
1711                         apply = 0;
1712                         summary = 1;
1713                         continue;
1714                 }
1715                 if (!strcmp(arg, "--check")) {
1716                         apply = 0;
1717                         check = 1;
1718                         continue;
1719                 }
1720                 if (!strcmp(arg, "--index")) {
1721                         check_index = 1;
1722                         continue;
1723                 }
1724                 if (!strcmp(arg, "--apply")) {
1725                         apply = 1;
1726                         continue;
1727                 }
1728                 if (!strcmp(arg, "--index-info")) {
1729                         apply = 0;
1730                         show_index_info = 1;
1731                         continue;
1732                 }
1733                 if (!strcmp(arg, "-z")) {
1734                         line_termination = 0;
1735                         continue;
1736                 }
1737                 fd = open(arg, O_RDONLY);
1738                 if (fd < 0)
1739                         usage(apply_usage);
1740                 read_stdin = 0;
1741                 apply_patch(fd);
1742                 close(fd);
1743         }
1744         if (read_stdin)
1745                 apply_patch(0);
1746         return 0;
1747 }