From: Junio C Hamano <junkio@cox.net>
Date: Mon, 24 Apr 2006 07:33:28 +0000 (-0700)
Subject: Merge part of 'jc/cache-tree'
X-Git-Tag: v1.4.1-rc1~187
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/5b5e4d64874823b0041a542c6fca415023174eb3

Merge part of 'jc/cache-tree'
---

5b5e4d64874823b0041a542c6fca415023174eb3
diff --cc update-index.c
index facec8d915,86f53948fc..ea1a377057
--- a/update-index.c
+++ b/update-index.c
@@@ -6,7 -6,11 +6,12 @@@
  #include "cache.h"
  #include "strbuf.h"
  #include "quote.h"
 +#include "tree-walk.h"
+ #include "tree.h"
+ #include "cache-tree.h"
+ 
+ static unsigned char active_cache_sha1[20];
+ static struct cache_tree *active_cache_tree;
  
  /*
   * Default to not allowing changes to the list of files. The
@@@ -348,13 -360,11 +361,14 @@@ static void chmod_path(int flip, const 
  	case '-':
  		ce->ce_mode &= htonl(~0111); break;
  	default:
 -		return -1;
 +		goto fail;
  	}
+ 	cache_tree_invalidate_path(active_cache_tree, path);
  	active_cache_changed = 1;
 -	return 0;
 +	report("chmod %cx '%s'", flip, path);
 +	return;
 + fail:
 +	die("git-update-index: cannot chmod %cx '%s'", flip, path);
  }
  
  static struct cache_file cache_file;
@@@ -475,124 -487,6 +491,125 @@@ static void read_index_info(int line_te
  static const char update_index_usage[] =
  "git-update-index [-q] [--add] [--replace] [--remove] [--unmerged] [--refresh] [--cacheinfo] [--chmod=(+|-)x] [--info-only] [--force-remove] [--stdin] [--index-info] [--ignore-missing] [-z] [--verbose] [--] <file>...";
  
 +static unsigned char head_sha1[20];
 +static unsigned char merge_head_sha1[20];
 +
 +static struct cache_entry *read_one_ent(const char *which,
 +					unsigned char *ent, const char *path,
 +					int namelen, int stage)
 +{
 +	unsigned mode;
 +	unsigned char sha1[20];
 +	int size;
 +	struct cache_entry *ce;
 +
 +	if (get_tree_entry(ent, path, sha1, &mode)) {
 +		error("%s: not in %s branch.", path, which);
 +		return NULL;
 +	}
 +	if (mode == S_IFDIR) {
 +		error("%s: not a blob in %s branch.", path, which);
 +		return NULL;
 +	}
 +	size = cache_entry_size(namelen);
 +	ce = xcalloc(1, size);
 +
 +	memcpy(ce->sha1, sha1, 20);
 +	memcpy(ce->name, path, namelen);
 +	ce->ce_flags = create_ce_flags(namelen, stage);
 +	ce->ce_mode = create_ce_mode(mode);
 +	return ce;
 +}
 +
 +static int unresolve_one(const char *path)
 +{
 +	int namelen = strlen(path);
 +	int pos;
 +	int ret = 0;
 +	struct cache_entry *ce_2 = NULL, *ce_3 = NULL;
 +
 +	/* See if there is such entry in the index. */
 +	pos = cache_name_pos(path, namelen);
 +	if (pos < 0) {
 +		/* If there isn't, either it is unmerged, or
 +		 * resolved as "removed" by mistake.  We do not
 +		 * want to do anything in the former case.
 +		 */
 +		pos = -pos-1;
 +		if (pos < active_nr) {
 +			struct cache_entry *ce = active_cache[pos];
 +			if (ce_namelen(ce) == namelen &&
 +			    !memcmp(ce->name, path, namelen)) {
 +				fprintf(stderr,
 +					"%s: skipping still unmerged path.\n",
 +					path);
 +				goto free_return;
 +			}
 +		}
 +	}
 +
 +	/* Grab blobs from given path from HEAD and MERGE_HEAD,
 +	 * stuff HEAD version in stage #2,
 +	 * stuff MERGE_HEAD version in stage #3.
 +	 */
 +	ce_2 = read_one_ent("our", head_sha1, path, namelen, 2);
 +	ce_3 = read_one_ent("their", merge_head_sha1, path, namelen, 3);
 +
 +	if (!ce_2 || !ce_3) {
 +		ret = -1;
 +		goto free_return;
 +	}
 +	if (!memcmp(ce_2->sha1, ce_3->sha1, 20) &&
 +	    ce_2->ce_mode == ce_3->ce_mode) {
 +		fprintf(stderr, "%s: identical in both, skipping.\n",
 +			path);
 +		goto free_return;
 +	}
 +
++	cache_tree_invalidate_path(active_cache_tree, path);
 +	remove_file_from_cache(path);
 +	if (add_cache_entry(ce_2, ADD_CACHE_OK_TO_ADD)) {
 +		error("%s: cannot add our version to the index.", path);
 +		ret = -1;
 +		goto free_return;
 +	}
 +	if (!add_cache_entry(ce_3, ADD_CACHE_OK_TO_ADD))
 +		return 0;
 +	error("%s: cannot add their version to the index.", path);
 +	ret = -1;
 + free_return:
 +	free(ce_2);
 +	free(ce_3);
 +	return ret;
 +}
 +
 +static void read_head_pointers(void)
 +{
 +	if (read_ref(git_path("HEAD"), head_sha1))
 +		die("No HEAD -- no initial commit yet?\n");
 +	if (read_ref(git_path("MERGE_HEAD"), merge_head_sha1)) {
 +		fprintf(stderr, "Not in the middle of a merge.\n");
 +		exit(0);
 +	}
 +}
 +
 +static int do_unresolve(int ac, const char **av)
 +{
 +	int i;
 +	int err = 0;
 +
 +	/* Read HEAD and MERGE_HEAD; if MERGE_HEAD does not exist, we
 +	 * are not doing a merge, so exit with success status.
 +	 */
 +	read_head_pointers();
 +
 +	for (i = 1; i < ac; i++) {
 +		const char *arg = av[i];
 +		err |= unresolve_one(arg);
 +	}
 +	return err;
 +}
 +
  int main(int argc, const char **argv)
  {
  	int i, newfd, entries, has_errors = 0, line_termination = '\n';
@@@ -746,12 -629,12 +764,14 @@@
  				free(path_name);
  		}
  	}
 +
 + finish:
  	if (active_cache_changed) {
- 		if (write_cache(newfd, active_cache, active_nr) ||
+ 		if (write_cache_1(newfd, active_cache, active_nr,
+ 				  active_cache_sha1) ||
  		    commit_index_file(&cache_file))
  			die("Unable to write new cachefile");
+ 		write_cache_tree(active_cache_sha1, active_cache_tree);
  	}
  
  	return has_errors ? 1 : 0;