Use Daniel's read-tree in the merge strategy 'resolve'.

diff --git a/apply.c b/apply.c
index a3474b788bca2b1dbbeba4c417a5489b4ae1c273..964df2db10c22d6ed0b89532e0af8cf9a43e607c 100644 (file)
--- a/apply.c
+++ b/apply.c
@@ -13,7 +13,7 @@
  * uses the working tree as a "branch" for a 3-way merge.
  */
 #include <ctype.h>
-
+#include <fnmatch.h>
 #include "cache.h"
 
 // We default to the merge behaviour, since that's what most people would
@@ -387,7 +387,7 @@ static char *git_header_name(char *line)
                default:
                        continue;
                case '\n':
-                       break;
+                       return NULL;
                case '\t': case ' ':
                        second = name+len;
                        for (;;) {
@@ -563,7 +563,7 @@ static int find_header(char *line, unsigned long size, int *hdrsize, struct patc
                        struct fragment dummy;
                        if (parse_fragment_header(line, len, &dummy) < 0)
                                continue;
-                       error("patch fragment without header at line %d: %.*s", linenr, len-1, line);
+                       error("patch fragment without header at line %d: %.*s", linenr, (int)len-1, line);
                }
 
                if (size < len + 6)
@@ -672,13 +672,24 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s
                        added++;
                        newlines--;
                        break;
-               /* We allow "\ No newline at end of file" */
+
+                /* We allow "\ No newline at end of file". Depending
+                 * on locale settings when the patch was produced we
+                 * don't know what this line looks like. The only
+                 * thing we do know is that it begins with "\ ". */
                case '\\':
-                       if (len < 12 || memcmp(line, "\\ No newline", 12))
+                       if (len < 12 || memcmp(line, "\\ ", 2))
                                return -1;
                        break;
                }
        }
+       /* If a fragment ends with an incomplete line, we failed to include
+        * it in the above loop because we hit oldlines == newlines == 0
+        * before seeing it.
+        */
+       if (12 < size && !memcmp(line, "\\ ", 2))
+               offset += linelen(line, size);
+
        patch->lines_added += added;
        patch->lines_deleted += deleted;
        return offset;
@@ -730,6 +741,7 @@ static const char minuses[]= "--------------------------------------------------
 
 static void show_stats(struct patch *patch)
 {
+       const char *prefix = "";
        char *name = patch->new_name;
        int len, max, add, del, total;
 
@@ -743,8 +755,15 @@ static void show_stats(struct patch *patch)
        max = max_len;
        if (max > 50)
                max = 50;
-       if (len > max)
+       if (len > max) {
+               char *slash;
+               prefix = "...";
+               max -= 3;
                name += len - max;
+               slash = strchr(name, '/');
+               if (slash)
+                       name = slash;
+       }
        len = max;
 
        /*
@@ -763,7 +782,7 @@ static void show_stats(struct patch *patch)
                add = (add * max + max_change / 2) / max_change;
                del = total - add;
        }
-       printf(" %-*s |%5d %.*s%.*s\n",
+       printf(" %s%-*s |%5d %.*s%.*s\n", prefix,
                len, name, patch->lines_added + patch->lines_deleted,
                add, pluses, del, minuses);
 }
@@ -900,7 +919,7 @@ static int apply_one_fragment(struct buffer_desc *desc, struct fragment *frag)
                 * last one (which is the newline, of course).
                 */
                plen = len-1;
-               if (len > size && patch[len] == '\\')
+               if (len < size && patch[len] == '\\')
                        plen--;
                switch (*patch) {
                case ' ':
@@ -953,7 +972,7 @@ static int apply_fragments(struct buffer_desc *desc, struct patch *patch)
 
        while (frag) {
                if (apply_one_fragment(desc, frag) < 0)
-                       return error("patch failed: %s:%d", patch->old_name, frag->oldpos);
+                       return error("patch failed: %s:%ld", patch->old_name, frag->oldpos);
                frag = frag->next;
        }
        return 0;
@@ -1028,8 +1047,12 @@ static int check_patch(struct patch *patch)
                        return error("%s: already exists in working directory", new_name);
                if (errno != ENOENT)
                        return error("%s: %s", new_name, strerror(errno));
-               if (!patch->new_mode)
-                       patch->new_mode = S_IFREG | 0644;
+               if (!patch->new_mode) {
+                       if (patch->is_new)
+                               patch->new_mode = S_IFREG | 0644;
+                       else
+                               patch->new_mode = patch->old_mode;
+               }
        }
 
        if (new_name && old_name) {
@@ -1338,9 +1361,9 @@ static void write_out_one_result(struct patch *patch)
        create_file(patch);
 }
 
-static void write_out_results(struct patch *list)
+static void write_out_results(struct patch *list, int skipped_patch)
 {
-       if (!list)
+       if (!list && !skipped_patch)
                die("No changes");
 
        while (list) {
@@ -1351,12 +1374,30 @@ static void write_out_results(struct patch *list)
 
 static struct cache_file cache_file;
 
+static struct excludes {
+       struct excludes *next;
+       const char *path;
+} *excludes;
+
+static int use_patch(struct patch *p)
+{
+       const char *pathname = p->new_name ? p->new_name : p->old_name;
+       struct excludes *x = excludes;
+       while (x) {
+               if (fnmatch(x->path, pathname, 0) == 0)
+                       return 0;
+               x = x->next;
+       }
+       return 1;
+}
+
 static int apply_patch(int fd)
 {
        int newfd;
        unsigned long offset, size;
        char *buffer = read_patch_file(fd, &size);
        struct patch *list = NULL, **listp = &list;
+       int skipped_patch = 0;
 
        if (!buffer)
                return -1;
@@ -1370,9 +1411,15 @@ static int apply_patch(int fd)
                nr = parse_chunk(buffer + offset, size, patch);
                if (nr < 0)
                        break;
-               patch_stats(patch);
-               *listp = patch;
-               listp = &patch->next;
+               if (use_patch(patch)) {
+                       patch_stats(patch);
+                       *listp = patch;
+                       listp = &patch->next;
+               } else {
+                       /* perhaps free it a bit better? */
+                       free(patch);
+                       skipped_patch++;
+               }
                offset += nr;
                size -= nr;
        }
@@ -1390,7 +1437,7 @@ static int apply_patch(int fd)
                exit(1);
 
        if (apply)
-               write_out_results(list);
+               write_out_results(list, skipped_patch);
 
        if (write_index) {
                if (write_cache(newfd, active_cache, active_nr) ||
@@ -1425,6 +1472,13 @@ int main(int argc, char **argv)
                        read_stdin = 0;
                        continue;
                }
+               if (!strncmp(arg, "--exclude=", 10)) {
+                       struct excludes *x = xmalloc(sizeof(*x));
+                       x->path = arg + 10;
+                       x->next = excludes;
+                       excludes = x;
+                       continue;
+               }
                /* NEEDSWORK: this does not do anything at this moment. */
                if (!strcmp(arg, "--no-merge")) {
                        merge_patch = 0;