From: Junio C Hamano <junkio@cox.net>
Date: Mon, 29 May 2006 06:05:02 +0000 (-0700)
Subject: Merge branch 'jc/lt-tree-n-cache-tree' into next
X-Git-Tag: v1.4.1-rc1~54
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/52bc0e294c0d5924db0e5e8f25284e467c6d2983?hp=-c

Merge branch 'jc/lt-tree-n-cache-tree' into next

* jc/lt-tree-n-cache-tree:
Remove "tree->entries" tree-entry list from tree parser
Switch "read_tree_recursive()" over to tree-walk functionality
Make "tree_entry" have a SHA1 instead of a union of object pointers
Add raw tree buffer info to "struct tree"
Don't use "sscanf()" for tree mode scanning
git-fetch: avoid using "case ... in (arm)"
---

52bc0e294c0d5924db0e5e8f25284e467c6d2983
diff --combined builtin-read-tree.c
index 629d151639,b93178a4ba..6a2ceba9ce
--- a/builtin-read-tree.c
+++ b/builtin-read-tree.c
@@@ -10,6 -10,7 +10,7 @@@
  #include "object.h"
  #include "tree.h"
  #include "cache-tree.h"
+ #include "tree-walk.h"
  #include <sys/time.h>
  #include <signal.h>
  #include "builtin.h"
@@@ -23,7 -24,6 +24,7 @@@ static int trivial_merges_only = 0
  static int aggressive = 0;
  static int verbose_update = 0;
  static volatile int progress_update = 0;
 +static const char *prefix = NULL;
  
  static int head_idx = -1;
  static int merge_size = 0;
@@@ -40,7 -40,7 +41,7 @@@ static struct tree_entry_list df_confli
  
  typedef int (*merge_fn_t)(struct cache_entry **src);
  
- static int entcmp(char *name1, int dir1, char *name2, int dir2)
+ static int entcmp(const char *name1, int dir1, const char *name2, int dir2)
  {
  	int len1 = strlen(name1);
  	int len2 = strlen(name2);
@@@ -68,7 -68,7 +69,7 @@@ static int unpack_trees_rec(struct tree
  	int src_size = len + 1;
  	do {
  		int i;
- 		char *first;
+ 		const char *first;
  		int firstdir = 0;
  		int pathlen;
  		unsigned ce_size;
@@@ -162,9 -162,10 +163,10 @@@
  			}
  
  			if (posns[i]->directory) {
+ 				struct tree *tree = lookup_tree(posns[i]->sha1);
  				any_dirs = 1;
- 				parse_tree(posns[i]->item.tree);
- 				subposns[i] = posns[i]->item.tree->entries;
+ 				parse_tree(tree);
+ 				subposns[i] = create_tree_entry_list(tree);
  				posns[i] = posns[i]->next;
  				src[i + merge] = &df_conflict_entry;
  				continue;
@@@ -188,7 -189,7 +190,7 @@@
  
  			any_files = 1;
  
- 			memcpy(ce->sha1, posns[i]->item.any->sha1, 20);
+ 			memcpy(ce->sha1, posns[i]->sha1, 20);
  			src[i + merge] = ce;
  			subposns[i] = &df_conflict_list;
  			posns[i] = posns[i]->next;
@@@ -369,11 -370,10 +371,11 @@@ static int unpack_trees(merge_fn_t fn
  	if (len) {
  		posns = xmalloc(len * sizeof(struct tree_entry_list *));
  		for (i = 0; i < len; i++) {
- 			posns[i] = ((struct tree *) posn->item)->entries;
+ 			posns[i] = create_tree_entry_list((struct tree *) posn->item);
  			posn = posn->next;
  		}
 -		if (unpack_trees_rec(posns, len, "", fn, &indpos))
 +		if (unpack_trees_rec(posns, len, prefix ? prefix : "",
 +				     fn, &indpos))
  			return -1;
  	}
  
@@@ -722,28 -722,6 +724,28 @@@ static int twoway_merge(struct cache_en
  		return deleted_entry(oldtree, current);
  }
  
 +/*
 + * Bind merge.
 + *
 + * Keep the index entries at stage0, collapse stage1 but make sure
 + * stage0 does not have anything there.
 + */
 +static int bind_merge(struct cache_entry **src)
 +{
 +	struct cache_entry *old = src[0];
 +	struct cache_entry *a = src[1];
 +
 +	if (merge_size != 1)
 +		return error("Cannot do a bind merge of %d trees\n",
 +			     merge_size);
 +	if (a && old)
 +		die("Entry '%s' overlaps.  Cannot bind.", a->name);
 +	if (!a)
 +		return keep_entry(old);
 +	else
 +		return merged_entry(a, NULL);
 +}
 +
  /*
   * One-way merge.
   *
@@@ -759,10 -737,8 +761,10 @@@ static int oneway_merge(struct cache_en
  		return error("Cannot do a oneway merge of %d trees",
  			     merge_size);
  
 -	if (!a)
 +	if (!a) {
 +		invalidate_ce_path(old);
  		return deleted_entry(old, old);
 +	}
  	if (old && same(old, a)) {
  		if (reset) {
  			struct stat st;
@@@ -800,19 -776,31 +802,31 @@@ static int read_cache_unmerged(void
  
  static void prime_cache_tree_rec(struct cache_tree *it, struct tree *tree)
  {
- 	struct tree_entry_list *ent;
- 	int cnt;
+ 	struct tree_desc desc;
+ 	int cnt = 0;
  
  	memcpy(it->sha1, tree->object.sha1, 20);
- 	for (cnt = 0, ent = tree->entries; ent; ent = ent->next) {
- 		if (!ent->directory)
+ 	desc.buf = tree->buffer;
+ 	desc.size = tree->size;
+ 
+ 	while (desc.size) {
+ 		unsigned mode;
+ 		const char *name;
+ 		const unsigned char *sha1;
+ 
+ 		sha1 = tree_entry_extract(&desc, &name, &mode);
+ 		update_tree_entry(&desc);
+ 
+ 		if (!S_ISDIR(mode))
  			cnt++;
  		else {
  			struct cache_tree_sub *sub;
- 			struct tree *subtree = (struct tree *)ent->item.tree;
+ 			struct tree *subtree;
+ 
+ 			subtree = lookup_tree(sha1);
  			if (!subtree->object.parsed)
  				parse_tree(subtree);
- 			sub = cache_tree_sub(it, ent->name);
+ 			sub = cache_tree_sub(it, name);
  			sub->cache_tree = cache_tree();
  			prime_cache_tree_rec(sub->cache_tree, subtree);
  			cnt += sub->cache_tree->entry_count;
@@@ -831,7 -819,7 +845,7 @@@ static void prime_cache_tree(void
  
  }
  
 -static const char read_tree_usage[] = "git-read-tree (<sha> | -m [--aggressive] [-u | -i] <sha1> [<sha2> [<sha3>]])";
 +static const char read_tree_usage[] = "git-read-tree (<sha> | [[-m [--aggressive] | --reset | --prefix=<prefix>] [-u | -i]] <sha1> [<sha2> [<sha3>]])";
  
  static struct cache_file cache_file;
  
@@@ -876,24 -864,9 +890,24 @@@ int cmd_read_tree(int argc, const char 
  			continue;
  		}
  
 +		/* "--prefix=<subdirectory>/" means keep the current index
 +		 *  entries and put the entries from the tree under the
 +		 * given subdirectory.
 +		 */
 +		if (!strncmp(arg, "--prefix=", 9)) {
 +			if (stage || merge || prefix)
 +				usage(read_tree_usage);
 +			prefix = arg + 9;
 +			merge = 1;
 +			stage = 1;
 +			if (read_cache_unmerged())
 +				die("you need to resolve your current index first");
 +			continue;
 +		}
 +
  		/* This differs from "-m" in that we'll silently ignore unmerged entries */
  		if (!strcmp(arg, "--reset")) {
 -			if (stage || merge)
 +			if (stage || merge || prefix)
  				usage(read_tree_usage);
  			reset = 1;
  			merge = 1;
@@@ -914,7 -887,7 +928,7 @@@
  
  		/* "-m" stands for "merge", meaning we start in stage 1 */
  		if (!strcmp(arg, "-m")) {
 -			if (stage || merge)
 +			if (stage || merge || prefix)
  				usage(read_tree_usage);
  			if (read_cache_unmerged())
  				die("you need to resolve your current index first");
@@@ -936,31 -909,12 +950,31 @@@
  	if ((update||index_only) && !merge)
  		usage(read_tree_usage);
  
 +	if (prefix) {
 +		int pfxlen = strlen(prefix);
 +		int pos;
 +		if (prefix[pfxlen-1] != '/')
 +			die("prefix must end with /");
 +		if (stage != 2)
 +			die("binding merge takes only one tree");
 +		pos = cache_name_pos(prefix, pfxlen);
 +		if (0 <= pos)
 +			die("corrupt index file");
 +		pos = -pos-1;
 +		if (pos < active_nr &&
 +		    !strncmp(active_cache[pos]->name, prefix, pfxlen))
 +			die("subdirectory '%s' already exists.", prefix);
 +		pos = cache_name_pos(prefix, pfxlen-1);
 +		if (0 <= pos)
 +			die("file '%.*s' already exists.", pfxlen-1, prefix);
 +	}
 +
  	if (merge) {
  		if (stage < 2)
  			die("just how do you expect me to merge %d trees?", stage-1);
  		switch (stage - 1) {
  		case 1:
 -			fn = oneway_merge;
 +			fn = prefix ? bind_merge : oneway_merge;
  			break;
  		case 2:
  			fn = twoway_merge;
diff --combined fetch.c
index ae92d5212e,d9fe41f34f..ae65b42056
--- a/fetch.c
+++ b/fetch.c
@@@ -8,7 -8,6 +8,7 @@@
  #include "refs.h"
  
  const char *write_ref = NULL;
 +const char *write_ref_log_details = NULL;
  
  int get_tree = 0;
  int get_history = 0;
@@@ -42,16 -41,22 +42,22 @@@ static int process_tree(struct tree *tr
  	if (parse_tree(tree))
  		return -1;
  
- 	entry = tree->entries;
- 	tree->entries = NULL;
+ 	entry = create_tree_entry_list(tree);
  	while (entry) {
  		struct tree_entry_list *next = entry->next;
- 		if (process(entry->item.any))
- 			return -1;
- 		free(entry->name);
+ 
+ 		if (entry->directory) {
+ 			struct tree *tree = lookup_tree(entry->sha1);
+ 			process_tree(tree);
+ 		} else {
+ 			struct blob *blob = lookup_blob(entry->sha1);
+ 			process(&blob->object);
+ 		}
  		free(entry);
  		entry = next;
  	}
+ 	free(tree->buffer);
+ 	tree->buffer = NULL;
  	return 0;
  }
  
@@@ -203,48 -208,23 +209,48 @@@ static int mark_complete(const char *pa
  
  int pull(char *target)
  {
 +	struct ref_lock *lock;
  	unsigned char sha1[20];
 +	char *msg;
 +	int ret;
  
  	save_commit_buffer = 0;
  	track_object_refs = 0;
 +	if (write_ref) {
 +		lock = lock_ref_sha1(write_ref, NULL, 0);
 +		if (!lock) {
 +			error("Can't lock ref %s", write_ref);
 +			return -1;
 +		}
 +	}
  
  	if (!get_recover)
  		for_each_ref(mark_complete);
  
 -	if (interpret_target(target, sha1))
 -		return error("Could not interpret %s as something to pull",
 -			     target);
 -	if (process(lookup_unknown_object(sha1)))
 +	if (interpret_target(target, sha1)) {
 +		error("Could not interpret %s as something to pull", target);
 +		unlock_ref(lock);
  		return -1;
 -	if (loop())
 +	}
 +	if (process(lookup_unknown_object(sha1))) {
 +		unlock_ref(lock);
  		return -1;
 -	
 -	if (write_ref)
 -		write_ref_sha1_unlocked(write_ref, sha1);
 +	}
 +	if (loop()) {
 +		unlock_ref(lock);
 +		return -1;
 +	}
 +
 +	if (write_ref) {
 +		if (write_ref_log_details) {
 +			msg = xmalloc(strlen(write_ref_log_details) + 12);
 +			sprintf(msg, "fetch from %s", write_ref_log_details);
 +		} else
 +			msg = NULL;
 +		ret = write_ref_sha1(lock, sha1, msg ? msg : "fetch (unknown)");
 +		if (msg)
 +			free(msg);
 +		return ret;
 +	}
  	return 0;
  }