X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=read-tree.c;h=49436bf96fa4df29e4e12c587c2de4f9c68e7e21;hb=7f498065e9bf85f6f3e954ec57dedf56fec29e01;hp=4422dbf424a5f4fd491811648acd3273aba529f3;hpb=b411fda15df4897a1308bbb5950088ea6138cbad;p=git.git

diff --git a/read-tree.c b/read-tree.c
index 4422dbf4..49436bf9 100644
--- a/read-tree.c
+++ b/read-tree.c
@@ -9,6 +9,7 @@
 
 #include "object.h"
 #include "tree.h"
+#include "cache-tree.h"
 #include <sys/time.h>
 #include <signal.h>
 
@@ -133,11 +134,9 @@ static int unpack_trees_rec(struct tree_entry_list **posns, int len,
 		pathlen = strlen(first);
 		ce_size = cache_entry_size(baselen + pathlen);
 
-		src = xmalloc(sizeof(struct cache_entry *) * src_size);
-		memset(src, 0, sizeof(struct cache_entry *) * src_size);
+		src = xcalloc(src_size, sizeof(struct cache_entry *));
 
-		subposns = xmalloc(sizeof(struct tree_list_entry *) * len);
-		memset(subposns, 0, sizeof(struct tree_list_entry *) * len);
+		subposns = xcalloc(len, sizeof(struct tree_list_entry *));
 
 		if (cache_name && !strcmp(cache_name, first)) {
 			any_files = 1;
@@ -177,8 +176,7 @@ static int unpack_trees_rec(struct tree_entry_list **posns, int len,
 			else
 				ce_stage = 2;
 
-			ce = xmalloc(ce_size);
-			memset(ce, 0, ce_size);
+			ce = xcalloc(1, ce_size);
 			ce->ce_mode = create_ce_mode(posns[i]->mode);
 			ce->ce_flags = create_ce_flags(baselen + pathlen,
 						       ce_stage);
@@ -424,6 +422,12 @@ static void verify_uptodate(struct cache_entry *ce)
 	die("Entry '%s' not uptodate. Cannot merge.", ce->name);
 }
 
+static void invalidate_ce_path(struct cache_entry *ce)
+{
+	if (ce)
+		cache_tree_invalidate_path(active_cache_tree, ce->name);
+}
+
 static int merged_entry(struct cache_entry *merge, struct cache_entry *old)
 {
 	merge->ce_flags |= htons(CE_UPDATE);
@@ -439,8 +443,11 @@ static int merged_entry(struct cache_entry *merge, struct cache_entry *old)
 			*merge = *old;
 		} else {
 			verify_uptodate(old);
+			invalidate_ce_path(old);
 		}
 	}
+	else
+		invalidate_ce_path(merge);
 	merge->ce_flags &= ~htons(CE_STAGEMASK);
 	add_cache_entry(merge, ADD_CACHE_OK_TO_ADD);
 	return 1;
@@ -452,6 +459,7 @@ static int deleted_entry(struct cache_entry *ce, struct cache_entry *old)
 		verify_uptodate(old);
 	ce->ce_mode = 0;
 	add_cache_entry(ce, ADD_CACHE_OK_TO_ADD);
+	invalidate_ce_path(ce);
 	return 1;
 }
 
@@ -686,8 +694,10 @@ static int oneway_merge(struct cache_entry **src)
 		return error("Cannot do a oneway merge of %d trees",
 			     merge_size);
 
-	if (!a)
+	if (!a) {
+		invalidate_ce_path(old);
 		return 0;
+	}
 	if (old && same(old, a)) {
 		return keep_entry(old);
 	}
@@ -706,6 +716,7 @@ static int read_cache_unmerged(void)
 		struct cache_entry *ce = active_cache[i];
 		if (ce_stage(ce)) {
 			deleted++;
+			invalidate_ce_path(ce);
 			continue;
 		}
 		if (deleted)
@@ -716,6 +727,39 @@ static int read_cache_unmerged(void)
 	return deleted;
 }
 
+static void prime_cache_tree_rec(struct cache_tree *it, struct tree *tree)
+{
+	struct tree_entry_list *ent;
+	int cnt;
+	
+	memcpy(it->sha1, tree->object.sha1, 20);
+	for (cnt = 0, ent = tree->entries; ent; ent = ent->next) {
+		if (!ent->directory)
+			cnt++;
+		else {
+			struct cache_tree_sub *sub;
+			struct tree *subtree = (struct tree *)ent->item.tree;
+			if (!subtree->object.parsed)
+				parse_tree(subtree);
+			sub = cache_tree_sub(it, ent->name);
+			sub->cache_tree = cache_tree();
+			prime_cache_tree_rec(sub->cache_tree, subtree);
+			cnt += sub->cache_tree->entry_count;
+		}
+	}
+	it->entry_count = cnt;
+}
+
+static void prime_cache_tree(void)
+{
+	struct tree *tree = (struct tree *)trees->item;
+	if (!tree)
+		return;
+	active_cache_tree = cache_tree();
+	prime_cache_tree_rec(active_cache_tree, tree);
+
+}
+
 static const char read_tree_usage[] = "git-read-tree (<sha> | -m [--aggressive] [-u | -i] <sha1> [<sha2> [<sha3>]])";
 
 static struct cache_file cache_file;
@@ -817,10 +861,9 @@ int main(int argc, char **argv)
 			fn = twoway_merge;
 			break;
 		case 3:
-			fn = threeway_merge;
-			break;
 		default:
 			fn = threeway_merge;
+			cache_tree_free(&active_cache_tree);
 			break;
 		}
 
@@ -831,6 +874,18 @@ int main(int argc, char **argv)
 	}
 
 	unpack_trees(fn);
+
+	/*
+	 * When reading only one tree (either the most basic form,
+	 * "-m ent" or "--reset ent" form), we can obtain a fully
+	 * valid cache-tree because the index must match exactly
+	 * what came from the tree.
+	 */
+	if (trees && trees->item && (!merge || (stage == 2))) {
+		cache_tree_free(&active_cache_tree);
+		prime_cache_tree();
+	}
+
 	if (write_cache(newfd, active_cache, active_nr) ||
 	    commit_index_file(&cache_file))
 		die("unable to write new index file");