refs: print error message in debug output

[thirdparty/git.git] / unpack-trees.c

diff --git a/unpack-trees.c b/unpack-trees.c
index 89ca95ce90b369bc521fc52fc9b071c467a74022..98e2f2e0e6f7470f77d92782b86aa8ad8be00943 100644 (file)
--- a/unpack-trees.c
+++ b/unpack-trees.c
@@ -645,17 +645,24 @@ static void mark_ce_used_same_name(struct cache_entry *ce,
        }
 }
 
-static struct cache_entry *next_cache_entry(struct unpack_trees_options *o)
+static struct cache_entry *next_cache_entry(struct unpack_trees_options *o, int *hint)
 {
        const struct index_state *index = o->src_index;
        int pos = o->cache_bottom;
 
+       if (*hint > pos)
+               pos = *hint;
+
        while (pos < index->cache_nr) {
                struct cache_entry *ce = index->cache[pos];
-               if (!(ce->ce_flags & CE_UNPACKED))
+               if (!(ce->ce_flags & CE_UNPACKED)) {
+                       *hint = pos + 1;
                        return ce;
+               }
                pos++;
        }
+
+       *hint = pos;
        return NULL;
 }
 
@@ -1231,7 +1238,9 @@ static int find_cache_pos(struct traverse_info *info,
 
 /*
  * Given a sparse directory entry 'ce', compare ce->name to
- * info->name + '/' + p->path + '/' if info->name is non-empty.
+ * info->traverse_path + p->path + '/' if info->traverse_path
+ * is non-empty.
+ *
  * Compare ce->name to p->path + '/' otherwise. Note that
  * ce->name must end in a trailing '/' because it is a sparse
  * directory entry.
@@ -1243,11 +1252,11 @@ static int sparse_dir_matches_path(const struct cache_entry *ce,
        assert(S_ISSPARSEDIR(ce->ce_mode));
        assert(ce->name[ce->ce_namelen - 1] == '/');
 
-       if (info->namelen)
-               return ce->ce_namelen == info->namelen + p->pathlen + 2 &&
-                      ce->name[info->namelen] == '/' &&
-                      !strncmp(ce->name, info->name, info->namelen) &&
-                      !strncmp(ce->name + info->namelen + 1, p->path, p->pathlen);
+       if (info->pathlen)
+               return ce->ce_namelen == info->pathlen + p->pathlen + 1 &&
+                      ce->name[info->pathlen - 1] == '/' &&
+                      !strncmp(ce->name, info->traverse_path, info->pathlen) &&
+                      !strncmp(ce->name + info->pathlen, p->path, p->pathlen);
        return ce->ce_namelen == p->pathlen + 1 &&
               !strncmp(ce->name, p->path, p->pathlen);
 }
@@ -1365,12 +1374,13 @@ static int unpack_callback(int n, unsigned long mask, unsigned long dirmask, str
 
        /* Are we supposed to look at the index too? */
        if (o->merge) {
+               int hint = -1;
                while (1) {
                        int cmp;
                        struct cache_entry *ce;
 
                        if (o->diff_index_cached)
-                               ce = next_cache_entry(o);
+                               ce = next_cache_entry(o, &hint);
                        else
                                ce = find_cache_entry(info, p);
 
@@ -1690,7 +1700,7 @@ static int verify_absent(const struct cache_entry *,
 int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options *o)
 {
        struct repository *repo = the_repository;
-       int i, ret;
+       int i, hint, ret;
        static struct cache_entry *dfc;
        struct pattern_list pl;
        int free_pattern_list = 0;
@@ -1779,13 +1789,15 @@ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options
                info.pathspec = o->pathspec;
 
                if (o->prefix) {
+                       hint = -1;
+
                        /*
                         * Unpack existing index entries that sort before the
                         * prefix the tree is spliced into.  Note that o->merge
                         * is always true in this case.
                         */
                        while (1) {
-                               struct cache_entry *ce = next_cache_entry(o);
+                               struct cache_entry *ce = next_cache_entry(o, &hint);
                                if (!ce)
                                        break;
                                if (ce_in_traverse_path(ce, &info))
@@ -1806,8 +1818,9 @@ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options
 
        /* Any left-over entries in the index? */
        if (o->merge) {
+               hint = -1;
                while (1) {
-                       struct cache_entry *ce = next_cache_entry(o);
+                       struct cache_entry *ce = next_cache_entry(o, &hint);
                        if (!ce)
                                break;
                        if (unpack_index_entry(ce, o) < 0)