Deprecate support for .git/info/grafts

diff --git a/diffcore-delta.c b/diffcore-delta.c
index d9729e5ec27d2ff2bacf4ed930195f9293f8ca5a..c83d45a0470d412c29f8c392e84bb010150dbb2a 100644 (file)
--- a/diffcore-delta.c
+++ b/diffcore-delta.c
@@ -46,33 +46,18 @@ struct spanhash_top {
        struct spanhash data[FLEX_ARRAY];
 };
 
-static struct spanhash *spanhash_find(struct spanhash_top *top,
-                                     unsigned int hashval)
-{
-       int sz = 1 << top->alloc_log2;
-       int bucket = hashval & (sz - 1);
-       while (1) {
-               struct spanhash *h = &(top->data[bucket++]);
-               if (!h->cnt)
-                       return NULL;
-               if (h->hashval == hashval)
-                       return h;
-               if (sz <= bucket)
-                       bucket = 0;
-       }
-}
-
 static struct spanhash_top *spanhash_rehash(struct spanhash_top *orig)
 {
-       struct spanhash_top *new;
+       struct spanhash_top *new_spanhash;
        int i;
        int osz = 1 << orig->alloc_log2;
        int sz = osz << 1;
 
-       new = xmalloc(sizeof(*orig) + sizeof(struct spanhash) * sz);
-       new->alloc_log2 = orig->alloc_log2 + 1;
-       new->free = INITIAL_FREE(new->alloc_log2);
-       memset(new->data, 0, sizeof(struct spanhash) * sz);
+       new_spanhash = xmalloc(st_add(sizeof(*orig),
+                            st_mult(sizeof(struct spanhash), sz)));
+       new_spanhash->alloc_log2 = orig->alloc_log2 + 1;
+       new_spanhash->free = INITIAL_FREE(new_spanhash->alloc_log2);
+       memset(new_spanhash->data, 0, sizeof(struct spanhash) * sz);
        for (i = 0; i < osz; i++) {
                struct spanhash *o = &(orig->data[i]);
                int bucket;
@@ -80,11 +65,11 @@ static struct spanhash_top *spanhash_rehash(struct spanhash_top *orig)
                        continue;
                bucket = o->hashval & (sz - 1);
                while (1) {
-                       struct spanhash *h = &(new->data[bucket++]);
+                       struct spanhash *h = &(new_spanhash->data[bucket++]);
                        if (!h->cnt) {
                                h->hashval = o->hashval;
                                h->cnt = o->cnt;
-                               new->free--;
+                               new_spanhash->free--;
                                break;
                        }
                        if (sz <= bucket)
@@ -92,7 +77,7 @@ static struct spanhash_top *spanhash_rehash(struct spanhash_top *orig)
                }
        }
        free(orig);
-       return new;
+       return new_spanhash;
 }
 
 static struct spanhash_top *add_spanhash(struct spanhash_top *top,
@@ -122,6 +107,20 @@ static struct spanhash_top *add_spanhash(struct spanhash_top *top,
        }
 }
 
+static int spanhash_cmp(const void *a_, const void *b_)
+{
+       const struct spanhash *a = a_;
+       const struct spanhash *b = b_;
+
+       /* A count of zero compares at the end.. */
+       if (!a->cnt)
+               return !b->cnt ? 0 : 1;
+       if (!b->cnt)
+               return -1;
+       return a->hashval < b->hashval ? -1 :
+               a->hashval > b->hashval ? 1 : 0;
+}
+
 static struct spanhash_top *hash_chars(struct diff_filespec *one)
 {
        int i, n;
@@ -132,7 +131,8 @@ static struct spanhash_top *hash_chars(struct diff_filespec *one)
        int is_text = !diff_filespec_is_binary(one);
 
        i = INITIAL_HASH_SIZE;
-       hash = xmalloc(sizeof(*hash) + sizeof(struct spanhash) * (1<<i));
+       hash = xmalloc(st_add(sizeof(*hash),
+                             st_mult(sizeof(struct spanhash), 1<<i)));
        hash->alloc_log2 = i;
        hash->free = INITIAL_FREE(i);
        memset(hash->data, 0, sizeof(struct spanhash) * (1<<i));
@@ -158,6 +158,7 @@ static struct spanhash_top *hash_chars(struct diff_filespec *one)
                n = 0;
                accum1 = accum2 = 0;
        }
+       QSORT(hash->data, 1ul << hash->alloc_log2, spanhash_cmp);
        return hash;
 }
 
@@ -165,11 +166,10 @@ int diffcore_count_changes(struct diff_filespec *src,
                           struct diff_filespec *dst,
                           void **src_count_p,
                           void **dst_count_p,
-                          unsigned long delta_limit,
                           unsigned long *src_copied,
                           unsigned long *literal_added)
 {
-       int i, ssz;
+       struct spanhash *s, *d;
        struct spanhash_top *src_count, *dst_count;
        unsigned long sc, la;
 
@@ -190,22 +190,35 @@ int diffcore_count_changes(struct diff_filespec *src,
        }
        sc = la = 0;
 
-       ssz = 1 << src_count->alloc_log2;
-       for (i = 0; i < ssz; i++) {
-               struct spanhash *s = &(src_count->data[i]);
-               struct spanhash *d;
+       s = src_count->data;
+       d = dst_count->data;
+       for (;;) {
                unsigned dst_cnt, src_cnt;
                if (!s->cnt)
-                       continue;
+                       break; /* we checked all in src */
+               while (d->cnt) {
+                       if (d->hashval >= s->hashval)
+                               break;
+                       la += d->cnt;
+                       d++;
+               }
                src_cnt = s->cnt;
-               d = spanhash_find(dst_count, s->hashval);
-               dst_cnt = d ? d->cnt : 0;
+               dst_cnt = 0;
+               if (d->cnt && d->hashval == s->hashval) {
+                       dst_cnt = d->cnt;
+                       d++;
+               }
                if (src_cnt < dst_cnt) {
                        la += dst_cnt - src_cnt;
                        sc += src_cnt;
                }
                else
                        sc += dst_cnt;
+               s++;
+       }
+       while (d->cnt) {
+               la += d->cnt;
+               d++;
        }
 
        if (!src_count_p)