git-read-tree: remove deleted files in the working directory

diff --git a/diff.c b/diff.c
index d7cde8fa056d5f83fe7b97ce44b6c86b87201f80..046d9a39293fa5d33529b59a251f626785ced233 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -236,6 +236,7 @@ static struct sha1_size_cache {
 static int sha1_size_cache_nr, sha1_size_cache_alloc;
 
 static struct sha1_size_cache *locate_size_cache(unsigned char *sha1,
+                                                int find_only,
                                                 unsigned long size)
 {
        int first, last;
@@ -244,9 +245,9 @@ static struct sha1_size_cache *locate_size_cache(unsigned char *sha1,
        first = 0;
        last = sha1_size_cache_nr;
        while (last > first) {
-               int next = (last + first) >> 1;
+               int cmp, next = (last + first) >> 1;
                e = sha1_size_cache[next];
-               int cmp = memcmp(e->sha1, sha1, 20);
+               cmp = memcmp(e->sha1, sha1, 20);
                if (!cmp)
                        return e;
                if (cmp < 0) {
@@ -256,7 +257,7 @@ static struct sha1_size_cache *locate_size_cache(unsigned char *sha1,
                first = next+1;
        }
        /* not found */
-       if (size == UINT_MAX)
+       if (find_only)
                return NULL;
        /* insert to make it at "first" */
        if (sha1_size_cache_alloc <= sha1_size_cache_nr) {
@@ -333,21 +334,22 @@ int diff_populate_filespec(struct diff_filespec *s, int size_only)
                close(fd);
        }
        else {
-               /* We cannot do size only for SHA1 blobs */
                char type[20];
                struct sha1_size_cache *e;
 
                if (size_only) {
-                       e = locate_size_cache(s->sha1, UINT_MAX);
+                       e = locate_size_cache(s->sha1, 1, 0);
                        if (e) {
                                s->size = e->size;
                                return 0;
                        }
+                       if (!sha1_file_size(s->sha1, &s->size))
+                               locate_size_cache(s->sha1, 0, s->size);
+               }
+               else {
+                       s->data = read_sha1_file(s->sha1, type, &s->size);
+                       s->should_free = 1;
                }
-               s->data = read_sha1_file(s->sha1, type, &s->size);
-               s->should_free = 1;
-               if (s->data && size_only)
-                       locate_size_cache(s->sha1, s->size);
        }
        return 0;
 }
@@ -588,6 +590,57 @@ void diff_setup(int flags)
        
 }
 
+static int parse_num(const char **cp_p)
+{
+       int num, scale, ch, cnt;
+       const char *cp = *cp_p;
+
+       cnt = num = 0;
+       scale = 1;
+       while ('0' <= (ch = *cp) && ch <= '9') {
+               if (cnt++ < 5) {
+                       /* We simply ignore more than 5 digits precision. */
+                       scale *= 10;
+                       num = num * 10 + ch - '0';
+               }
+               *cp++;
+       }
+       *cp_p = cp;
+
+       /* user says num divided by scale and we say internally that
+        * is MAX_SCORE * num / scale.
+        */
+       return (MAX_SCORE * num / scale);
+}
+
+int diff_scoreopt_parse(const char *opt)
+{
+       int opt1, opt2, cmd;
+
+       if (*opt++ != '-')
+               return -1;
+       cmd = *opt++;
+       if (cmd != 'M' && cmd != 'C' && cmd != 'B')
+               return -1; /* that is not a -M, -C nor -B option */
+
+       opt1 = parse_num(&opt);
+       if (cmd != 'B')
+               opt2 = 0;
+       else {
+               if (*opt == 0)
+                       opt2 = 0;
+               else if (*opt != '/')
+                       return -1; /* we expect -B80/99 or -B80 */
+               else {
+                       opt++;
+                       opt2 = parse_num(&opt);
+               }
+       }
+       if (*opt != 0)
+               return -1;
+       return opt1 | (opt2 << 16);
+}
+
 struct diff_queue_struct diff_queued_diff;
 
 void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp)
@@ -733,8 +786,8 @@ static void diff_flush_patch(struct diff_filepair *p)
        case 'R':
                sprintf(msg_,
                        "similarity index %d%%\n"
-                       "rename old %s\n"
-                       "rename new %s",
+                       "rename from %s\n"
+                       "rename to %s",
                        (int)(0.5 + p->score * 100.0/MAX_SCORE),
                        p->one->path, p->two->path);
                msg = msg_;
@@ -854,12 +907,14 @@ static void diff_resolve_rename_copy(void)
                else if (memcmp(p->one->sha1, p->two->sha1, 20) ||
                         p->one->mode != p->two->mode)
                        p->status = 'M';
-               else
-                       /* this is a "no-change" entry.
-                        * should not happen anymore.
-                        * p->status = 'X';
+               else {
+                       /* This is a "no-change" entry and should not
+                        * happen anymore, but prepare for broken callers.
                         */
-                       die("internal error in diffcore: unmodified entry remains");
+                       error("feeding unmodified %s to diffcore",
+                             p->one->path);
+                       p->status = 'X';
+               }
        }
        diff_debug_queue("resolve-rename-copy done", q);
 }
@@ -909,10 +964,12 @@ void diffcore_std(const char **paths,
 {
        if (paths && paths[0])
                diffcore_pathspec(paths);
-       if (0 <= break_opt)
+       if (break_opt != -1)
                diffcore_break(break_opt);
        if (detect_rename)
                diffcore_rename(detect_rename, rename_score);
+       if (break_opt != -1)
+               diffcore_merge_broken();
        if (pickaxe)
                diffcore_pickaxe(pickaxe, pickaxe_opts);
        if (orderfile)