Fix earlier mismerges.

diff --git a/pack-objects.c b/pack-objects.c
index 5b2ef9a51387dc01e9d31f08962101cf1323e3e2..3590cd5e5983cde07016f7a1f20ce146b6a73703 100644 (file)
--- a/pack-objects.c
+++ b/pack-objects.c
@@ -156,7 +156,7 @@ static void prepare_pack_revindex(struct pack_revindex *rix)
 
        rix->revindex = xmalloc(sizeof(unsigned long) * (num_ent + 1));
        for (i = 0; i < num_ent; i++) {
-               long hl = *((long *)(index + 24 * i));
+               unsigned int hl = *((unsigned int *)(index + 24 * i));
                rix->revindex[i] = ntohl(hl);
        }
        /* This knows the pack format -- the 20-byte trailer
@@ -690,25 +690,20 @@ static void add_pbase_object(struct tree_desc *tree,
                             const char *name,
                             int cmplen)
 {
-       while (tree->size) {
-               const unsigned char *sha1;
-               const char *entry_name;
-               int entry_len;
-               unsigned mode;
+       struct name_entry entry;
+
+       while (tree_entry(tree,&entry)) {
                unsigned long size;
                char type[20];
 
-               sha1 = tree_entry_extract(tree, &entry_name, &mode);
-               update_tree_entry(tree);
-               entry_len = strlen(entry_name);
-               if (entry_len != cmplen ||
-                   memcmp(entry_name, name, cmplen) ||
-                   !has_sha1_file(sha1) ||
-                   sha1_object_info(sha1, type, &size))
+               if (entry.pathlen != cmplen ||
+                   memcmp(entry.path, name, cmplen) ||
+                   !has_sha1_file(entry.sha1) ||
+                   sha1_object_info(entry.sha1, type, &size))
                        continue;
                if (name[cmplen] != '/') {
                        unsigned hash = name_hash(up, name);
-                       add_object_entry(sha1, hash, 1);
+                       add_object_entry(entry.sha1, hash, 1);
                        return;
                }
                if (!strcmp(type, tree_type)) {
@@ -718,15 +713,15 @@ static void add_pbase_object(struct tree_desc *tree,
                        const char *down = name+cmplen+1;
                        int downlen = name_cmp_len(down);
 
-                       tree = pbase_tree_get(sha1);
+                       tree = pbase_tree_get(entry.sha1);
                        if (!tree)
                                return;
                        sub.buf = tree->tree_data;
                        sub.size = tree->tree_size;
 
                        me.up = up;
-                       me.elem = entry_name;
-                       me.len = entry_len;
+                       me.elem = entry.path;
+                       me.len = entry.pathlen;
                        add_pbase_object(&sub, &me, down, downlen);
                        pbase_tree_put(tree);
                }
@@ -1036,10 +1031,13 @@ static int try_delta(struct unpacked *trg, struct unpacked *src,
        if (src_entry->depth >= max_depth)
                return 0;
 
-       /* Now some size filtering euristics. */
+       /* Now some size filtering heuristics. */
        size = trg_entry->size;
-       max_size = size / 2 - 20;
-       if (trg_entry->delta)
+       max_size = size/2 - 20;
+       max_size = max_size * (max_depth - src_entry->depth) / max_depth;
+       if (max_size == 0)
+               return 0;
+       if (trg_entry->delta && trg_entry->delta_size <= max_size)
                max_size = trg_entry->delta_size-1;
        src_size = src_entry->size;
        sizediff = src_size < size ? size - src_size : 0;
@@ -1104,17 +1102,14 @@ static void find_deltas(struct object_entry **list, int window, int depth)
 
                if (entry->size < 50)
                        continue;
-               if (n->index)
-                       free_delta_index(n->index);
+               free_delta_index(n->index);
+               n->index = NULL;
                free(n->data);
                n->entry = entry;
                n->data = read_sha1_file(entry->sha1, type, &size);
                if (size != entry->size)
                        die("object %s inconsistent object length (%lu vs %lu)",
                            sha1_to_hex(entry->sha1), size, entry->size);
-               n->index = create_delta_index(n->data, size);
-               if (!n->index)
-                       die("out of memory");
 
                j = window;
                while (--j > 0) {
@@ -1128,15 +1123,17 @@ static void find_deltas(struct object_entry **list, int window, int depth)
                        if (try_delta(n, m, m->index, depth) < 0)
                                break;
                }
-#if 0
                /* if we made n a delta, and if n is already at max
                 * depth, leaving it in the window is pointless.  we
                 * should evict it first.
-                * ... in theory only; somehow this makes things worse.
                 */
                if (entry->delta && depth <= entry->depth)
                        continue;
-#endif
+
+               n->index = create_delta_index(n->data, size);
+               if (!n->index)
+                       die("out of memory");
+
                idx++;
                if (idx >= window)
                        idx = 0;
@@ -1146,8 +1143,7 @@ static void find_deltas(struct object_entry **list, int window, int depth)
                fputc('\n', stderr);
 
        for (i = 0; i < window; ++i) {
-               if (array[i].index)
-                       free_delta_index(array[i].index);
+               free_delta_index(array[i].index);
                free(array[i].data);
        }
        free(array);
@@ -1243,6 +1239,7 @@ int main(int argc, char **argv)
 
        setup_git_directory();
 
+       progress = isatty(2);
        for (i = 1; i < argc; i++) {
                const char *arg = argv[i];
 
@@ -1273,6 +1270,10 @@ int main(int argc, char **argv)
                                        usage(pack_usage);
                                continue;
                        }
+                       if (!strcmp("--progress", arg)) {
+                               progress = 1;
+                               continue;
+                       }
                        if (!strcmp("-q", arg)) {
                                progress = 0;
                                continue;