From: Junio C Hamano <gitster@pobox.com>
Date: Thu, 10 Feb 2011 00:41:17 +0000 (-0800)
Subject: Merge branch 'jc/unpack-trees'
X-Git-Tag: v1.7.5-rc0~139
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/75513914784bb75447c71e3b001612ee37af386c?ds=inline;hp=-c

Merge branch 'jc/unpack-trees'

* jc/unpack-trees:
unpack_trees(): skip trees that are the same in all input
unpack-trees.c: cosmetic fix

Conflicts:
unpack-trees.c
---

75513914784bb75447c71e3b001612ee37af386c
diff --combined unpack-trees.c
index bf204b9210,e1b4e996ae..149bc5d358
--- a/unpack-trees.c
+++ b/unpack-trees.c
@@@ -231,11 -231,20 +231,11 @@@ static int check_updates(struct unpack_
  static int verify_uptodate_sparse(struct cache_entry *ce, struct unpack_trees_options *o);
  static int verify_absent_sparse(struct cache_entry *ce, enum unpack_trees_error_types, struct unpack_trees_options *o);
  
 -static int will_have_skip_worktree(const struct cache_entry *ce, struct unpack_trees_options *o)
 -{
 -	const char *basename;
 -
 -	basename = strrchr(ce->name, '/');
 -	basename = basename ? basename+1 : ce->name;
 -	return excluded_from_list(ce->name, ce_namelen(ce), basename, NULL, o->el) <= 0;
 -}
 -
  static int apply_sparse_checkout(struct cache_entry *ce, struct unpack_trees_options *o)
  {
  	int was_skip_worktree = ce_skip_worktree(ce);
  
 -	if (!ce_stage(ce) && will_have_skip_worktree(ce, o))
 +	if (ce->ce_flags & CE_NEW_SKIP_WORKTREE)
  		ce->ce_flags |= CE_SKIP_WORKTREE;
  	else
  		ce->ce_flags &= ~CE_SKIP_WORKTREE;
@@@ -310,7 -319,7 +310,7 @@@ static void mark_all_ce_unused(struct i
  {
  	int i;
  	for (i = 0; i < index->cache_nr; i++)
 -		index->cache[i]->ce_flags &= ~CE_UNPACKED;
 +		index->cache[i]->ce_flags &= ~(CE_UNPACKED | CE_ADDED | CE_NEW_SKIP_WORKTREE);
  }
  
  static int locate_in_src_index(struct cache_entry *ce,
@@@ -381,7 -390,7 +381,7 @@@ static void add_same_unmerged(struct ca
  static int unpack_index_entry(struct cache_entry *ce,
  			      struct unpack_trees_options *o)
  {
- 	struct cache_entry *src[5] = { NULL };
+ 	struct cache_entry *src[MAX_UNPACK_TREES + 1] = { NULL, };
  	int ret;
  
  	src[0] = ce;
@@@ -427,7 -436,14 +427,14 @@@ static int switch_cache_bottom(struct t
  	return ret;
  }
  
- static int traverse_trees_recursive(int n, unsigned long dirmask, unsigned long df_conflicts, struct name_entry *names, struct traverse_info *info)
+ static int fast_forward_merge(int n, unsigned long dirmask,
+ 			      struct name_entry *names,
+ 			      struct traverse_info *info);
+ 
+ static int traverse_trees_recursive(int n, unsigned long dirmask,
+ 				    unsigned long df_conflicts,
+ 				    struct name_entry *names,
+ 				    struct traverse_info *info)
  {
  	int i, ret, bottom;
  	struct tree_desc t[MAX_UNPACK_TREES];
@@@ -435,6 -451,11 +442,11 @@@
  	struct traverse_info newinfo;
  	struct name_entry *p;
  
+ 	if (!df_conflicts) {
+ 		int status = fast_forward_merge(n, dirmask, names, info);
+ 		if (status)
+ 			return status;
+ 	}
  	p = names;
  	while (!p->mode)
  		p++;
@@@ -682,6 -703,53 +694,53 @@@ static struct cache_entry *find_cache_e
  		return NULL;
  }
  
+ static int fast_forward_merge(int n, unsigned long dirmask,
+ 			      struct name_entry *names,
+ 			      struct traverse_info *info)
+ {
+ 	int i;
+ 	struct cache_entry *src[MAX_UNPACK_TREES + 1] = { NULL, };
+ 	struct unpack_trees_options *o = info->data;
+ 
+ 	/* merging two or more trees with an identical subdirectory? */
+ 	if ((n < 2) || ((1UL << n) - 1) != dirmask ||
+ 	    !o->merge || o->reset || o->initial_checkout)
+ 		return 0;
+ 	for (i = 1; i < n; i++)
+ 		if (hashcmp(names[i-1].sha1, names[i].sha1))
+ 			return 0;
+ 
+ 	/*
+ 	 * Instead of descending into the directory, keep the contents
+ 	 * of the current index.
+ 	 */
+ 	while (1) {
+ 		struct cache_entry *ce;
+ 		ce = next_cache_entry(o);
+ 		if (!ce)
+ 			break;
+ 		/* Is the entry still in that directory? */
+ 		if (do_compare_entry(ce, info, names))
+ 			break;
+ 		/*
+ 		 * Note: we do not just run unpack_index_entry() here,
+ 		 * as the callback may want to compare what is in the
+ 		 * index with what are from the HEAD and the other tree
+ 		 * and reject the merge.  We pretend that ancestors, the
+ 		 * HEAD and the other tree all have the same contents as
+ 		 * the current index, which is a lie, but it works.
+ 		 */
+ 		for (i = 0; i < n + 1; i++)
+ 			src[i] = ce;
+ 		mark_ce_used(ce, o);
+ 		if (call_unpack_fn(src, o) < 0)
+ 			return unpack_failed(o, NULL);
+ 		if (ce_stage(ce))
+ 			mark_ce_used_same_name(ce, o);
+ 	}
+ 	return dirmask;
+ }
+ 
  static void debug_path(struct traverse_info *info)
  {
  	if (info->prev) {
@@@ -811,177 -879,9 +870,177 @@@ static int unpack_callback(int n, unsig
  	return mask;
  }
  
 +/* Whole directory matching */
 +static int clear_ce_flags_dir(struct cache_entry **cache, int nr,
 +			      char *prefix, int prefix_len,
 +			      char *basename,
 +			      int select_mask, int clear_mask,
 +			      struct exclude_list *el)
 +{
 +	struct cache_entry **cache_end = cache + nr;
 +	int dtype = DT_DIR;
 +	int ret = excluded_from_list(prefix, prefix_len, basename, &dtype, el);
 +
 +	prefix[prefix_len++] = '/';
 +
 +	/* included, no clearing for any entries under this directory */
 +	if (!ret) {
 +		for (; cache != cache_end; cache++) {
 +			struct cache_entry *ce = *cache;
 +			if (strncmp(ce->name, prefix, prefix_len))
 +				break;
 +		}
 +		return nr - (cache_end - cache);
 +	}
 +
 +	/* excluded, clear all selected entries under this directory. */
 +	if (ret == 1) {
 +		for (; cache != cache_end; cache++) {
 +			struct cache_entry *ce = *cache;
 +			if (select_mask && !(ce->ce_flags & select_mask))
 +				continue;
 +			if (strncmp(ce->name, prefix, prefix_len))
 +				break;
 +			ce->ce_flags &= ~clear_mask;
 +		}
 +		return nr - (cache_end - cache);
 +	}
 +
 +	return 0;
 +}
 +
 +/*
 + * Traverse the index, find every entry that matches according to
 + * o->el. Do "ce_flags &= ~clear_mask" on those entries. Return the
 + * number of traversed entries.
 + *
 + * If select_mask is non-zero, only entries whose ce_flags has on of
 + * those bits enabled are traversed.
 + *
 + * cache	: pointer to an index entry
 + * prefix_len	: an offset to its path
 + *
 + * The current path ("prefix") including the trailing '/' is
 + *   cache[0]->name[0..(prefix_len-1)]
 + * Top level path has prefix_len zero.
 + */
 +static int clear_ce_flags_1(struct cache_entry **cache, int nr,
 +			    char *prefix, int prefix_len,
 +			    int select_mask, int clear_mask,
 +			    struct exclude_list *el)
 +{
 +	struct cache_entry **cache_end = cache + nr;
 +
 +	/*
 +	 * Process all entries that have the given prefix and meet
 +	 * select_mask condition
 +	 */
 +	while(cache != cache_end) {
 +		struct cache_entry *ce = *cache;
 +		const char *name, *slash;
 +		int len, dtype;
 +
 +		if (select_mask && !(ce->ce_flags & select_mask)) {
 +			cache++;
 +			continue;
 +		}
 +
 +		if (prefix_len && strncmp(ce->name, prefix, prefix_len))
 +			break;
 +
 +		name = ce->name + prefix_len;
 +		slash = strchr(name, '/');
 +
 +		/* If it's a directory, try whole directory match first */
 +		if (slash) {
 +			int processed;
 +
 +			len = slash - name;
 +			memcpy(prefix + prefix_len, name, len);
 +
 +			/*
 +			 * terminate the string (no trailing slash),
 +			 * clear_c_f_dir needs it
 +			 */
 +			prefix[prefix_len + len] = '\0';
 +			processed = clear_ce_flags_dir(cache, cache_end - cache,
 +						       prefix, prefix_len + len,
 +						       prefix + prefix_len,
 +						       select_mask, clear_mask,
 +						       el);
 +
 +			/* clear_c_f_dir eats a whole dir already? */
 +			if (processed) {
 +				cache += processed;
 +				continue;
 +			}
 +
 +			prefix[prefix_len + len++] = '/';
 +			cache += clear_ce_flags_1(cache, cache_end - cache,
 +						  prefix, prefix_len + len,
 +						  select_mask, clear_mask, el);
 +			continue;
 +		}
 +
 +		/* Non-directory */
 +		dtype = ce_to_dtype(ce);
 +		if (excluded_from_list(ce->name, ce_namelen(ce), name, &dtype, el) > 0)
 +			ce->ce_flags &= ~clear_mask;
 +		cache++;
 +	}
 +	return nr - (cache_end - cache);
 +}
 +
 +static int clear_ce_flags(struct cache_entry **cache, int nr,
 +			    int select_mask, int clear_mask,
 +			    struct exclude_list *el)
 +{
 +	char prefix[PATH_MAX];
 +	return clear_ce_flags_1(cache, nr,
 +				prefix, 0,
 +				select_mask, clear_mask,
 +				el);
 +}
 +
 +/*
 + * Set/Clear CE_NEW_SKIP_WORKTREE according to $GIT_DIR/info/sparse-checkout
 + */
 +static void mark_new_skip_worktree(struct exclude_list *el,
 +				   struct index_state *the_index,
 +				   int select_flag, int skip_wt_flag)
 +{
 +	int i;
 +
 +	/*
 +	 * 1. Pretend the narrowest worktree: only unmerged entries
 +	 * are checked out
 +	 */
 +	for (i = 0; i < the_index->cache_nr; i++) {
 +		struct cache_entry *ce = the_index->cache[i];
 +
 +		if (select_flag && !(ce->ce_flags & select_flag))
 +			continue;
 +
 +		if (!ce_stage(ce))
 +			ce->ce_flags |= skip_wt_flag;
 +		else
 +			ce->ce_flags &= ~skip_wt_flag;
 +	}
 +
 +	/*
 +	 * 2. Widen worktree according to sparse-checkout file.
 +	 * Matched entries will have skip_wt_flag cleared (i.e. "in")
 +	 */
 +	clear_ce_flags(the_index->cache, the_index->cache_nr,
 +		       select_flag, skip_wt_flag, el);
 +}
 +
 +static int verify_absent(struct cache_entry *, enum unpack_trees_error_types, struct unpack_trees_options *);
  /*
   * N-way merge "len" trees.  Returns 0 on success, -1 on failure to manipulate the
   * resulting index, -2 on failure to reflect the changes to the work tree.
 + *
 + * CE_ADDED, CE_UNPACKED and CE_NEW_SKIP_WORKTREE are used internally
   */
  int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options *o)
  {
@@@ -1014,12 -914,6 +1073,12 @@@
  	o->merge_size = len;
  	mark_all_ce_unused(o->src_index);
  
 +	/*
 +	 * Sparse checkout loop #1: set NEW_SKIP_WORKTREE on existing entries
 +	 */
 +	if (!o->skip_sparse_checkout)
 +		mark_new_skip_worktree(o->el, o->src_index, 0, CE_NEW_SKIP_WORKTREE);
 +
  	if (!dfc)
  		dfc = xcalloc(1, cache_entry_size(0));
  	o->df_conflict_entry = dfc;
@@@ -1073,29 -967,9 +1132,29 @@@
  
  	if (!o->skip_sparse_checkout) {
  		int empty_worktree = 1;
 +
 +		/*
 +		 * Sparse checkout loop #2: set NEW_SKIP_WORKTREE on entries not in loop #1
 +		 * If the will have NEW_SKIP_WORKTREE, also set CE_SKIP_WORKTREE
 +		 * so apply_sparse_checkout() won't attempt to remove it from worktree
 +		 */
 +		mark_new_skip_worktree(o->el, &o->result, CE_ADDED, CE_SKIP_WORKTREE | CE_NEW_SKIP_WORKTREE);
 +
  		for (i = 0; i < o->result.cache_nr; i++) {
  			struct cache_entry *ce = o->result.cache[i];
  
 +			/*
 +			 * Entries marked with CE_ADDED in merged_entry() do not have
 +			 * verify_absent() check (the check is effectively disabled
 +			 * because CE_NEW_SKIP_WORKTREE is set unconditionally).
 +			 *
 +			 * Do the real check now because we have had
 +			 * correct CE_NEW_SKIP_WORKTREE
 +			 */
 +			if (ce->ce_flags & CE_ADDED &&
 +			    verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o))
 +					return -1;
 +
  			if (apply_sparse_checkout(ce, o)) {
  				ret = -1;
  				goto done;
@@@ -1105,6 -979,7 +1164,7 @@@
  
  		}
  		if (o->result.cache_nr && empty_worktree) {
+ 			/* dubious---why should this fail??? */
  			ret = unpack_failed(o, "Sparse checkout leaves no entry on working directory");
  			goto done;
  		}
@@@ -1116,7 -991,11 +1176,7 @@@
  		*o->dst_index = o->result;
  
  done:
 -	for (i = 0; i < el.nr; i++)
 -		free(el.excludes[i]);
 -	if (el.excludes)
 -		free(el.excludes);
 -
 +	free_excludes(&el);
  	return ret;
  
  return_failed:
@@@ -1184,7 -1063,7 +1244,7 @@@ static int verify_uptodate_1(struct cac
  static int verify_uptodate(struct cache_entry *ce,
  			   struct unpack_trees_options *o)
  {
 -	if (!o->skip_sparse_checkout && will_have_skip_worktree(ce, o))
 +	if (!o->skip_sparse_checkout && (ce->ce_flags & CE_NEW_SKIP_WORKTREE))
  		return 0;
  	return verify_uptodate_1(ce, o, ERROR_NOT_UPTODATE_FILE);
  }
@@@ -1374,29 -1253,23 +1434,29 @@@ static int verify_absent_1(struct cache
  		char path[PATH_MAX + 1];
  		memcpy(path, ce->name, len);
  		path[len] = 0;
 -		lstat(path, &st);
 +		if (lstat(path, &st))
 +			return error("cannot stat '%s': %s", path,
 +					strerror(errno));
  
  		return check_ok_to_remove(path, len, DT_UNKNOWN, NULL, &st,
  				error_type, o);
 -	} else if (!lstat(ce->name, &st))
 +	} else if (lstat(ce->name, &st)) {
 +		if (errno != ENOENT)
 +			return error("cannot stat '%s': %s", ce->name,
 +				     strerror(errno));
 +		return 0;
 +	} else {
  		return check_ok_to_remove(ce->name, ce_namelen(ce),
 -				ce_to_dtype(ce), ce, &st,
 -				error_type, o);
 -
 -	return 0;
 +					  ce_to_dtype(ce), ce, &st,
 +					  error_type, o);
 +	}
  }
  
  static int verify_absent(struct cache_entry *ce,
  			 enum unpack_trees_error_types error_type,
  			 struct unpack_trees_options *o)
  {
 -	if (!o->skip_sparse_checkout && will_have_skip_worktree(ce, o))
 +	if (!o->skip_sparse_checkout && (ce->ce_flags & CE_NEW_SKIP_WORKTREE))
  		return 0;
  	return verify_absent_1(ce, error_type, o);
  }
@@@ -1418,23 -1291,10 +1478,23 @@@ static int merged_entry(struct cache_en
  	int update = CE_UPDATE;
  
  	if (!old) {
 +		/*
 +		 * New index entries. In sparse checkout, the following
 +		 * verify_absent() will be delayed until after
 +		 * traverse_trees() finishes in unpack_trees(), then:
 +		 *
 +		 *  - CE_NEW_SKIP_WORKTREE will be computed correctly
 +		 *  - verify_absent() be called again, this time with
 +		 *    correct CE_NEW_SKIP_WORKTREE
 +		 *
 +		 * verify_absent() call here does nothing in sparse
 +		 * checkout (i.e. o->skip_sparse_checkout == 0)
 +		 */
 +		update |= CE_ADDED;
 +		merge->ce_flags |= CE_NEW_SKIP_WORKTREE;
 +
  		if (verify_absent(merge, ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o))
  			return -1;
 -		if (!o->skip_sparse_checkout && will_have_skip_worktree(merge, o))
 -			update |= CE_SKIP_WORKTREE;
  		invalidate_ce_path(merge, o);
  	} else if (!(old->ce_flags & CE_CONFLICTED)) {
  		/*
@@@ -1450,8 -1310,8 +1510,8 @@@
  		} else {
  			if (verify_uptodate(old, o))
  				return -1;
 -			if (ce_skip_worktree(old))
 -				update |= CE_SKIP_WORKTREE;
 +			/* Migrate old flags over */
 +			update |= old->ce_flags & (CE_SKIP_WORKTREE | CE_NEW_SKIP_WORKTREE);
  			invalidate_ce_path(old, o);
  		}
  	} else {