cache-tree: update API to take abitrary flags

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/commit.c b/builtin/commit.c
index eba1377eb32c02e57c46364c381df940afa66048..bf42bb384d8046e6ecdf02bd38d6ee129383d046 100644 (file)
--- a/builtin/commit.c
+++ b/builtin/commit.c
@@ -400,7 +400,7 @@ static char *prepare_index(int argc, const char **argv, const char *prefix,
                fd = hold_locked_index(&index_lock, 1);
                add_files_to_cache(also ? prefix : NULL, pathspec, 0);
                refresh_cache_or_die(refresh_flags);
                fd = hold_locked_index(&index_lock, 1);
                add_files_to_cache(also ? prefix : NULL, pathspec, 0);
                refresh_cache_or_die(refresh_flags);

-               update_main_cache_tree(1);
+               update_main_cache_tree(WRITE_TREE_SILENT);

                if (write_cache(fd, active_cache, active_nr) ||
                    close_lock_file(&index_lock))
                        die(_("unable to write new_index file"));
                if (write_cache(fd, active_cache, active_nr) ||
                    close_lock_file(&index_lock))
                        die(_("unable to write new_index file"));


@@ -421,7 +421,7 @@ static char *prepare_index(int argc, const char **argv, const char *prefix,
                fd = hold_locked_index(&index_lock, 1);
                refresh_cache_or_die(refresh_flags);
                if (active_cache_changed) {
                fd = hold_locked_index(&index_lock, 1);
                refresh_cache_or_die(refresh_flags);
                if (active_cache_changed) {

-                       update_main_cache_tree(1);
+                       update_main_cache_tree(WRITE_TREE_SILENT);

                        if (write_cache(fd, active_cache, active_nr) ||
                            commit_locked_index(&index_lock))
                                die(_("unable to write new_index file"));
                        if (write_cache(fd, active_cache, active_nr) ||
                            commit_locked_index(&index_lock))
                                die(_("unable to write new_index file"));

diff --git a/cache-tree.c b/cache-tree.c
index 8de39590d57e14d08ee4d04b74965191aa905b29..c1eacafd19ecc33f8782a241ca3fb887611dbc43 100644 (file)
--- a/cache-tree.c
+++ b/cache-tree.c
@@ -150,9 +150,10 @@ void cache_tree_invalidate_path(struct cache_tree *it, const char *path)
 }
 
 static int verify_cache(struct cache_entry **cache,
 }
 
 static int verify_cache(struct cache_entry **cache,

-                       int entries, int silent)
+                       int entries, int flags)

 {
        int i, funny;
 {
        int i, funny;

+       int silent = flags & WRITE_TREE_SILENT;

 
        /* Verify that the tree is merged */
        funny = 0;
 
        /* Verify that the tree is merged */
        funny = 0;


@@ -241,10 +242,11 @@ static int update_one(struct cache_tree *it,
                      int entries,
                      const char *base,
                      int baselen,
                      int entries,
                      const char *base,
                      int baselen,

-                     int missing_ok,
-                     int dryrun)
+                     int flags)

 {
        struct strbuf buffer;
 {
        struct strbuf buffer;

+       int missing_ok = flags & WRITE_TREE_MISSING_OK;
+       int dryrun = flags & WRITE_TREE_DRY_RUN;

        int i;
 
        if (0 <= it->entry_count && has_sha1_file(it->sha1))
        int i;
 
        if (0 <= it->entry_count && has_sha1_file(it->sha1))


@@ -288,8 +290,7 @@ static int update_one(struct cache_tree *it,
                                    cache + i, entries - i,
                                    path,
                                    baselen + sublen + 1,
                                    cache + i, entries - i,
                                    path,
                                    baselen + sublen + 1,

-                                   missing_ok,
-                                   dryrun);
+                                   flags);

                if (subcnt < 0)
                        return subcnt;
                i += subcnt - 1;
                if (subcnt < 0)
                        return subcnt;
                i += subcnt - 1;


@@ -371,15 +372,13 @@ static int update_one(struct cache_tree *it,
 int cache_tree_update(struct cache_tree *it,
                      struct cache_entry **cache,
                      int entries,
 int cache_tree_update(struct cache_tree *it,
                      struct cache_entry **cache,
                      int entries,

-                     int missing_ok,
-                     int dryrun,
-                     int silent)
+                     int flags)

 {
        int i;
 {
        int i;

-       i = verify_cache(cache, entries, silent);
+       i = verify_cache(cache, entries, flags);

        if (i)
                return i;
        if (i)
                return i;

-       i = update_one(it, cache, entries, "", 0, missing_ok, dryrun);
+       i = update_one(it, cache, entries, "", 0, flags);

        if (i < 0)
                return i;
        return 0;
        if (i < 0)
                return i;
        return 0;


@@ -572,11 +571,9 @@ int write_cache_as_tree(unsigned char *sha1, int flags, const char *prefix)
 
        was_valid = cache_tree_fully_valid(active_cache_tree);
        if (!was_valid) {
 
        was_valid = cache_tree_fully_valid(active_cache_tree);
        if (!was_valid) {

-               int missing_ok = flags & WRITE_TREE_MISSING_OK;
-

                if (cache_tree_update(active_cache_tree,
                                      active_cache, active_nr,
                if (cache_tree_update(active_cache_tree,
                                      active_cache, active_nr,

-                                     missing_ok, 0, 0) < 0)
+                                     flags) < 0)

                        return WRITE_TREE_UNMERGED_INDEX;
                if (0 <= newfd) {
                        if (!write_cache(newfd, active_cache, active_nr) &&
                        return WRITE_TREE_UNMERGED_INDEX;
                if (0 <= newfd) {
                        if (!write_cache(newfd, active_cache, active_nr) &&


@@ -672,10 +669,10 @@ int cache_tree_matches_traversal(struct cache_tree *root,
        return 0;
 }
 
        return 0;
 }
 

-int update_main_cache_tree (int silent)
+int update_main_cache_tree(int flags)

 {
        if (!the_index.cache_tree)
                the_index.cache_tree = cache_tree();
        return cache_tree_update(the_index.cache_tree,
 {
        if (!the_index.cache_tree)
                the_index.cache_tree = cache_tree();
        return cache_tree_update(the_index.cache_tree,

-                                the_index.cache, the_index.cache_nr, 0, 0, silent);
+                                the_index.cache, the_index.cache_nr, flags);

 }
 }

diff --git a/cache-tree.h b/cache-tree.h
index 0ec0b2a159dfd352ca621322a9ce3715328ab2d0..d8cb2e9e39d2be9c4dad67db44a464c2a1004d2f 100644 (file)
--- a/cache-tree.h
+++ b/cache-tree.h
@@ -29,13 +29,15 @@ void cache_tree_write(struct strbuf *, struct cache_tree *root);
 struct cache_tree *cache_tree_read(const char *buffer, unsigned long size);
 
 int cache_tree_fully_valid(struct cache_tree *);
 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 cache_tree *, struct cache_entry **, int, int, int, int);
+int cache_tree_update(struct cache_tree *, struct cache_entry **, int, int);

 
 int update_main_cache_tree(int);
 
 /* bitmasks to write_cache_as_tree flags */
 #define WRITE_TREE_MISSING_OK 1
 #define WRITE_TREE_IGNORE_CACHE_TREE 2
 
 int update_main_cache_tree(int);
 
 /* bitmasks to write_cache_as_tree flags */
 #define WRITE_TREE_MISSING_OK 1
 #define WRITE_TREE_IGNORE_CACHE_TREE 2

+#define WRITE_TREE_DRY_RUN 4
+#define WRITE_TREE_SILENT 8

 
 /* error return codes */
 #define WRITE_TREE_UNREADABLE_INDEX (-1)
 
 /* error return codes */
 #define WRITE_TREE_UNREADABLE_INDEX (-1)

diff --git a/merge-recursive.c b/merge-recursive.c
index d83cd6c662847fb51641d7b8bf16739e588f67a2..6479a60cd112c5b06b354b1a251c60bb4bce972a 100644 (file)
--- a/merge-recursive.c
+++ b/merge-recursive.c
@@ -264,7 +264,7 @@ struct tree *write_tree_from_memory(struct merge_options *o)
 
        if (!cache_tree_fully_valid(active_cache_tree) &&
            cache_tree_update(active_cache_tree,
 
        if (!cache_tree_fully_valid(active_cache_tree) &&
            cache_tree_update(active_cache_tree,

-                             active_cache, active_nr, 0, 0, 0) < 0)
+                             active_cache, active_nr, 0) < 0)

                die("error building trees");
 
        result = lookup_tree(active_cache_tree->sha1);
                die("error building trees");
 
        result = lookup_tree(active_cache_tree->sha1);

diff --git a/test-dump-cache-tree.c b/test-dump-cache-tree.c
index e6c292385f9492ab8a58a693e854025a11b9b045..a6ffdf39d58bcb2b4469080e828dc8a5b0fbc675 100644 (file)
--- a/test-dump-cache-tree.c
+++ b/test-dump-cache-tree.c
@@ -59,6 +59,6 @@ int main(int ac, char **av)
        struct cache_tree *another = cache_tree();
        if (read_cache() < 0)
                die("unable to read index file");
        struct cache_tree *another = cache_tree();
        if (read_cache() < 0)
                die("unable to read index file");

-       cache_tree_update(another, active_cache, active_nr, 0, 1, 0);
+       cache_tree_update(another, active_cache, active_nr, WRITE_TREE_DRY_RUN);

        return dump_cache_tree(active_cache_tree, another, "");
 }
        return dump_cache_tree(active_cache_tree, another, "");
 }