cache-tree.c: remove the_repository references

This case is more interesting than other boring "remove the_repo"
commits because while we need access to the object database, we cannot
simply use r->index because unpack-trees.c can operate on a temporary
index, not $GIT_DIR/index. Ideally we should be able to pass an object
database to lookup_tree() but that ship has sailed.

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/read-tree.c b/builtin/read-tree.c
index fbbc98e5161f011a25743a528e6bb3f85e415f51..c05c12d0340d736022d7dd7856ad0797c87abb05 100644 (file)
--- a/builtin/read-tree.c
+++ b/builtin/read-tree.c
@@ -255,7 +255,9 @@ int cmd_read_tree(int argc, const char **argv, const char *unused_prefix)
         * what came from the tree.
         */
        if (nr_trees == 1 && !opts.prefix)
         * what came from the tree.
         */
        if (nr_trees == 1 && !opts.prefix)

-               prime_cache_tree(&the_index, trees[0]);
+               prime_cache_tree(the_repository,
+                                the_repository->index,
+                                trees[0]);

 
        if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
                die("unable to write new index file");
 
        if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
                die("unable to write new index file");

diff --git a/builtin/rebase.c b/builtin/rebase.c
index b9eb9584542bc9e1851c338e03991f055b58c947..d9bedecf86b5f52e1db174dbdb7107f43107e681 100644 (file)
--- a/builtin/rebase.c
+++ b/builtin/rebase.c
@@ -582,7 +582,7 @@ static int reset_head(struct object_id *oid, const char *action,
        }
 
        tree = parse_tree_indirect(oid);
        }
 
        tree = parse_tree_indirect(oid);

-       prime_cache_tree(the_repository->index, tree);
+       prime_cache_tree(the_repository, the_repository->index, tree);

 
        if (write_locked_index(the_repository->index, &lock, COMMIT_LOCK) < 0)
                ret = error(_("could not write index"));
 
        if (write_locked_index(the_repository->index, &lock, COMMIT_LOCK) < 0)
                ret = error(_("could not write index"));

diff --git a/builtin/reset.c b/builtin/reset.c
index 5b4bbb0fb5eebdc145c294dbfc0afabe10ac8620..161b5e0cae8df3a5648835c5877bc7e1e1f5d548 100644 (file)
--- a/builtin/reset.c
+++ b/builtin/reset.c
@@ -93,7 +93,7 @@ static int reset_index(const struct object_id *oid, int reset_type, int quiet)
 
        if (reset_type == MIXED || reset_type == HARD) {
                tree = parse_tree_indirect(oid);
 
        if (reset_type == MIXED || reset_type == HARD) {
                tree = parse_tree_indirect(oid);

-               prime_cache_tree(&the_index, tree);
+               prime_cache_tree(the_repository, the_repository->index, tree);

        }
 
        ret = 0;
        }
 
        ret = 0;

diff --git a/cache-tree.c b/cache-tree.c
index 9d454d24bca62dcdb8c941a64d09b7a53556323a..190c6e5aa6bbc79f5267fa96e3c14ed2438c0488 100644 (file)
--- a/cache-tree.c
+++ b/cache-tree.c
@@ -659,7 +659,9 @@ int write_index_as_tree(struct object_id *oid, struct index_state *index_state,
        return ret;
 }
 
        return ret;
 }
 

-static void prime_cache_tree_rec(struct cache_tree *it, struct tree *tree)
+static void prime_cache_tree_rec(struct repository *r,
+                                struct cache_tree *it,
+                                struct tree *tree)

 {
        struct tree_desc desc;
        struct name_entry entry;
 {
        struct tree_desc desc;
        struct name_entry entry;


@@ -673,24 +675,25 @@ static void prime_cache_tree_rec(struct cache_tree *it, struct tree *tree)
                        cnt++;
                else {
                        struct cache_tree_sub *sub;
                        cnt++;
                else {
                        struct cache_tree_sub *sub;

-                       struct tree *subtree = lookup_tree(the_repository,
-                                                          entry.oid);
+                       struct tree *subtree = lookup_tree(r, entry.oid);

                        if (!subtree->object.parsed)
                                parse_tree(subtree);
                        sub = cache_tree_sub(it, entry.path);
                        sub->cache_tree = cache_tree();
                        if (!subtree->object.parsed)
                                parse_tree(subtree);
                        sub = cache_tree_sub(it, entry.path);
                        sub->cache_tree = cache_tree();

-                       prime_cache_tree_rec(sub->cache_tree, subtree);
+                       prime_cache_tree_rec(r, sub->cache_tree, subtree);

                        cnt += sub->cache_tree->entry_count;
                }
        }
        it->entry_count = cnt;
 }
 
                        cnt += sub->cache_tree->entry_count;
                }
        }
        it->entry_count = cnt;
 }
 

-void prime_cache_tree(struct index_state *istate, struct tree *tree)
+void prime_cache_tree(struct repository *r,
+                     struct index_state *istate,
+                     struct tree *tree)

 {
        cache_tree_free(&istate->cache_tree);
        istate->cache_tree = cache_tree();
 {
        cache_tree_free(&istate->cache_tree);
        istate->cache_tree = cache_tree();

-       prime_cache_tree_rec(istate->cache_tree, tree);
+       prime_cache_tree_rec(r, istate->cache_tree, tree);

        istate->cache_changed |= CACHE_TREE_CHANGED;
 }
 
        istate->cache_changed |= CACHE_TREE_CHANGED;
 }
 


@@ -726,7 +729,8 @@ int cache_tree_matches_traversal(struct cache_tree *root,
        return 0;
 }
 
        return 0;
 }
 

-static void verify_one(struct index_state *istate,
+static void verify_one(struct repository *r,
+                      struct index_state *istate,

                       struct cache_tree *it,
                       struct strbuf *path)
 {
                       struct cache_tree *it,
                       struct strbuf *path)
 {


@@ -736,13 +740,13 @@ static void verify_one(struct index_state *istate,
 
        for (i = 0; i < it->subtree_nr; i++) {
                strbuf_addf(path, "%s/", it->down[i]->name);
 
        for (i = 0; i < it->subtree_nr; i++) {
                strbuf_addf(path, "%s/", it->down[i]->name);

-               verify_one(istate, it->down[i]->cache_tree, path);
+               verify_one(r, istate, it->down[i]->cache_tree, path);

                strbuf_setlen(path, len);
        }
 
        if (it->entry_count < 0 ||
            /* no verification on tests (t7003) that replace trees */
                strbuf_setlen(path, len);
        }
 
        if (it->entry_count < 0 ||
            /* no verification on tests (t7003) that replace trees */

-           lookup_replace_object(the_repository, &it->oid) != &it->oid)
+           lookup_replace_object(r, &it->oid) != &it->oid)

                return;
 
        if (path->len) {
                return;
 
        if (path->len) {


@@ -793,12 +797,12 @@ static void verify_one(struct index_state *istate,
        strbuf_release(&tree_buf);
 }
 
        strbuf_release(&tree_buf);
 }
 

-void cache_tree_verify(struct index_state *istate)
+void cache_tree_verify(struct repository *r, struct index_state *istate)

 {
        struct strbuf path = STRBUF_INIT;
 
        if (!istate->cache_tree)
                return;
 {
        struct strbuf path = STRBUF_INIT;
 
        if (!istate->cache_tree)
                return;

-       verify_one(istate, istate->cache_tree, &path);
+       verify_one(r, istate, istate->cache_tree, &path);

        strbuf_release(&path);
 }
        strbuf_release(&path);
 }

diff --git a/cache-tree.h b/cache-tree.h
index 0ab6784ffea5da0581c905738aaa66215266b5f9..326209198b60fa8a6fdbd171c46132b8a5062e04 100644 (file)
--- a/cache-tree.h
+++ b/cache-tree.h
@@ -32,7 +32,7 @@ struct cache_tree *cache_tree_read(const char *buffer, unsigned long size);
 
 int cache_tree_fully_valid(struct cache_tree *);
 int cache_tree_update(struct index_state *, int);
 
 int cache_tree_fully_valid(struct cache_tree *);
 int cache_tree_update(struct index_state *, int);

-void cache_tree_verify(struct index_state *);
+void cache_tree_verify(struct repository *, struct index_state *);

 
 /* bitmasks to write_cache_as_tree flags */
 #define WRITE_TREE_MISSING_OK 1
 
 /* bitmasks to write_cache_as_tree flags */
 #define WRITE_TREE_MISSING_OK 1


@@ -47,7 +47,7 @@ void cache_tree_verify(struct index_state *);
 #define WRITE_TREE_PREFIX_ERROR (-3)
 
 int write_index_as_tree(struct object_id *oid, struct index_state *index_state, const char *index_path, int flags, const char *prefix);
 #define WRITE_TREE_PREFIX_ERROR (-3)
 
 int write_index_as_tree(struct object_id *oid, struct index_state *index_state, const char *index_path, int flags, const char *prefix);

-void prime_cache_tree(struct index_state *, struct tree *);
+void prime_cache_tree(struct repository *, struct index_state *, struct tree *);

 
 int cache_tree_matches_traversal(struct cache_tree *, struct name_entry *ent, struct traverse_info *info);
 
 
 int cache_tree_matches_traversal(struct cache_tree *, struct name_entry *ent, struct traverse_info *info);
 

diff --git a/read-cache.c b/read-cache.c
index f3a848d61c154ec99b4c45d3404380810c18eec1..69944fc93388b009a4674d0adcbe19d6bfa3db2f 100644 (file)
--- a/read-cache.c
+++ b/read-cache.c
@@ -3126,7 +3126,7 @@ int write_locked_index(struct index_state *istate, struct lock_file *lock,
        struct split_index *si = istate->split_index;
 
        if (git_env_bool("GIT_TEST_CHECK_CACHE_TREE", 0))
        struct split_index *si = istate->split_index;
 
        if (git_env_bool("GIT_TEST_CHECK_CACHE_TREE", 0))

-               cache_tree_verify(istate);
+               cache_tree_verify(the_repository, istate);

 
        if ((flags & SKIP_IF_UNCHANGED) && !istate->cache_changed) {
                if (flags & COMMIT_LOCK)
 
        if ((flags & SKIP_IF_UNCHANGED) && !istate->cache_changed) {
                if (flags & COMMIT_LOCK)

diff --git a/sequencer.c b/sequencer.c
index 111cb747d60283ee8575936a0c20d5a27a377f84..726f7276445672cdaa7ce24a38189ab59dd047e7 100644 (file)
--- a/sequencer.c
+++ b/sequencer.c
@@ -2991,7 +2991,7 @@ static int do_reset(struct repository *r,
        }
 
        tree = parse_tree_indirect(&oid);
        }
 
        tree = parse_tree_indirect(&oid);

-       prime_cache_tree(r->index, tree);
+       prime_cache_tree(r, r->index, tree);

 
        if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
                ret = error(_("could not write index"));
 
        if (write_locked_index(r->index, &lock, COMMIT_LOCK) < 0)
                ret = error(_("could not write index"));

diff --git a/unpack-trees.c b/unpack-trees.c
index 7570df481bf69824e4b163a6c7a15985b72d1326..6d53cbfc865096ea41028c0601aa12d6eeb8a145 100644 (file)
--- a/unpack-trees.c
+++ b/unpack-trees.c
@@ -1630,7 +1630,7 @@ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options
                move_index_extensions(&o->result, o->src_index);
                if (!ret) {
                        if (git_env_bool("GIT_TEST_CHECK_CACHE_TREE", 0))
                move_index_extensions(&o->result, o->src_index);
                if (!ret) {
                        if (git_env_bool("GIT_TEST_CHECK_CACHE_TREE", 0))

-                               cache_tree_verify(&o->result);
+                               cache_tree_verify(the_repository, &o->result);

                        if (!o->result.cache_tree)
                                o->result.cache_tree = cache_tree();
                        if (!cache_tree_fully_valid(o->result.cache_tree))
                        if (!o->result.cache_tree)
                                o->result.cache_tree = cache_tree();
                        if (!cache_tree_fully_valid(o->result.cache_tree))