Merge branch 'nd/export-worktree'

diff --git a/builtin/index-pack.c b/builtin/index-pack.c
index 7ea2020d821004569a6913d9cf550149032a1b96..f07bc66ed6679cac715491f0b212aca0b8bcd625 100644 (file)
--- a/builtin/index-pack.c
+++ b/builtin/index-pack.c
@@ -616,7 +616,9 @@ static int compare_ofs_delta_bases(off_t offset1, off_t offset2,
        int cmp = type1 - type2;
        if (cmp)
                return cmp;
-       return offset1 - offset2;
+       return offset1 < offset2 ? -1 :
+              offset1 > offset2 ?  1 :
+              0;
 }
 
 static int find_ofs_delta(const off_t offset, enum object_type type)
@@ -784,7 +786,7 @@ static void sha1_object(const void *data, struct object_entry *obj_entry,
        assert(data || obj_entry);
 
        read_lock();
-       collision_test_needed = has_sha1_file(sha1);
+       collision_test_needed = has_sha1_file_with_flags(sha1, HAS_SHA1_QUICK);
        read_unlock();
 
        if (collision_test_needed && !data) {
@@ -1051,7 +1053,9 @@ static int compare_ofs_delta_entry(const void *a, const void *b)
        const struct ofs_delta_entry *delta_a = a;
        const struct ofs_delta_entry *delta_b = b;
 
-       return delta_a->offset - delta_b->offset;
+       return delta_a->offset < delta_b->offset ? -1 :
+              delta_a->offset > delta_b->offset ?  1 :
+              0;
 }
 
 static int compare_ref_delta_entry(const void *a, const void *b)
@@ -1223,7 +1227,7 @@ static void resolve_deltas(void)
  * - append objects to convert thin pack to full pack if required
  * - write the final 20-byte SHA-1
  */
-static void fix_unresolved_deltas(struct sha1file *f, int nr_unresolved);
+static void fix_unresolved_deltas(struct sha1file *f);
 static void conclude_pack(int fix_thin_pack, const char *curr_pack, unsigned char *pack_sha1)
 {
        if (nr_ref_deltas + nr_ofs_deltas == nr_resolved_deltas) {
@@ -1245,7 +1249,7 @@ static void conclude_pack(int fix_thin_pack, const char *curr_pack, unsigned cha
                memset(objects + nr_objects + 1, 0,
                       nr_unresolved * sizeof(*objects));
                f = sha1fd(output_fd, curr_pack);
-               fix_unresolved_deltas(f, nr_unresolved);
+               fix_unresolved_deltas(f);
                strbuf_addf(&msg, _("completed with %d local objects"),
                            nr_objects - nr_objects_initial);
                stop_progress_msg(&progress, msg.buf);
@@ -1327,10 +1331,10 @@ static int delta_pos_compare(const void *_a, const void *_b)
        return a->obj_no - b->obj_no;
 }
 
-static void fix_unresolved_deltas(struct sha1file *f, int nr_unresolved)
+static void fix_unresolved_deltas(struct sha1file *f)
 {
        struct ref_delta_entry **sorted_by_pos;
-       int i, n = 0;
+       int i;
 
        /*
         * Since many unresolved deltas may well be themselves base objects
@@ -1342,12 +1346,12 @@ static void fix_unresolved_deltas(struct sha1file *f, int nr_unresolved)
         * before deltas depending on them, a good heuristic is to start
         * resolving deltas in the same order as their position in the pack.
         */
-       sorted_by_pos = xmalloc(nr_unresolved * sizeof(*sorted_by_pos));
+       sorted_by_pos = xmalloc(nr_ref_deltas * sizeof(*sorted_by_pos));
        for (i = 0; i < nr_ref_deltas; i++)
-               sorted_by_pos[n++] = &ref_deltas[i];
-       qsort(sorted_by_pos, n, sizeof(*sorted_by_pos), delta_pos_compare);
+               sorted_by_pos[i] = &ref_deltas[i];
+       qsort(sorted_by_pos, nr_ref_deltas, sizeof(*sorted_by_pos), delta_pos_compare);
 
-       for (i = 0; i < n; i++) {
+       for (i = 0; i < nr_ref_deltas; i++) {
                struct ref_delta_entry *d = sorted_by_pos[i];
                enum object_type type;
                struct base_data *base_obj = alloc_base_data();