X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=merge-recursive.c;h=2ba43ae84b20f993ba175f728297cf5360066872;hb=173a9cbe7031bc3574b3f41cb2d2375cf959ff2a;hp=6f109f16ec2162932d7111f778ec41f4770002d7;hpb=bd669986f7ecfb0215e5d5fa29ec8449a6225bc1;p=git.git

diff --git a/merge-recursive.c b/merge-recursive.c
index 6f109f16e..2ba43ae84 100644
--- a/merge-recursive.c
+++ b/merge-recursive.c
@@ -19,7 +19,7 @@
 #include "diffcore.h"
 #include "run-command.h"
 #include "tag.h"
-
+#include "unpack-trees.h"
 #include "path-list.h"
 
 /*
@@ -43,24 +43,25 @@ static struct commit *make_virtual_commit(struct tree *tree, const char *comment
 	commit->tree = tree;
 	commit->util = (void*)comment;
 	*(int*)commit->object.sha1 = virtual_id++;
+	/* avoid warnings */
+	commit->object.parsed = 1;
 	return commit;
 }
 
 /*
- * TODO: we should not have to copy the SHA1s around, but rather reference
- * them. That way, sha_eq() is just sha1 == sha2.
+ * Since we use get_tree_entry(), which does not put the read object into
+ * the object pool, we cannot rely on a == b.
  */
 static int sha_eq(const unsigned char *a, const unsigned char *b)
 {
 	if (!a && !b)
 		return 2;
-	return a && b && memcmp(a, b, 20) == 0;
+	return a && b && hashcmp(a, b) == 0;
 }
 
 /*
- * TODO: check if we can just reuse the active_cache structure: it is already
- * sorted (by name, stage).
- * Only problem: do not write it when flushing the cache.
+ * Since we want to write the index eventually, we cannot reuse the index
+ * for these (temporary) data.
  */
 struct stage_data
 {
@@ -115,6 +116,7 @@ static void output_commit_title(struct commit *commit)
 	}
 }
 
+static const char *current_index_file = NULL;
 static const char *original_index_file;
 static const char *temporary_index_file;
 static int cache_dirty = 0;
@@ -123,12 +125,10 @@ static int flush_cache(void)
 {
 	/* flush temporary index */
 	struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
-	int fd = hold_lock_file_for_update(lock, getenv("GIT_INDEX_FILE"));
-	if (fd < 0)
-		die("could not lock %s", temporary_index_file);
+	int fd = hold_lock_file_for_update(lock, current_index_file, 1);
 	if (write_cache(fd, active_cache, active_nr) ||
 			close(fd) || commit_lock_file(lock))
-		die ("unable to write %s", getenv("GIT_INDEX_FILE"));
+		die ("unable to write %s", current_index_file);
 	discard_cache();
 	cache_dirty = 0;
 	return 0;
@@ -136,11 +136,12 @@ static int flush_cache(void)
 
 static void setup_index(int temp)
 {
-	const char *idx = temp ? temporary_index_file: original_index_file;
-	if (cache_dirty)
-		die("fatal: cache changed flush_cache();");
+	current_index_file = temp ? temporary_index_file: original_index_file;
+	if (cache_dirty) {
+		discard_cache();
+		cache_dirty = 0;
+	}
 	unlink(temporary_index_file);
-	setenv("GIT_INDEX_FILE", idx, 1);
 	discard_cache();
 }
 
@@ -157,7 +158,7 @@ static struct cache_entry *make_cache_entry(unsigned int mode,
 	size = cache_entry_size(len);
 	ce = xcalloc(1, size);
 
-	memcpy(ce->sha1, sha1, 20);
+	hashcpy(ce->sha1, sha1);
 	memcpy(ce->name, path, len);
 	ce->ce_flags = create_ce_flags(len, stage);
 	ce->ce_mode = create_ce_mode(mode);
@@ -173,7 +174,7 @@ static int add_cacheinfo(unsigned int mode, const unsigned char *sha1,
 {
 	struct cache_entry *ce;
 	if (!cache_dirty)
-		read_cache_from(getenv("GIT_INDEX_FILE"));
+		read_cache_from(current_index_file);
 	cache_dirty++;
 	ce = make_cache_entry(mode, sha1 ? sha1 : null_sha1, path, stage, refresh);
 	if (!ce)
@@ -192,86 +193,89 @@ static int add_cacheinfo(unsigned int mode, const unsigned char *sha1,
  */
 static int index_only = 0;
 
-/*
- * TODO: this can be streamlined by refactoring builtin-read-tree.c
- */
-static int git_read_tree(const struct tree *tree)
+static int git_read_tree(struct tree *tree)
 {
-#if 0
-	fprintf(stderr, "GIT_INDEX_FILE='%s' git-read-tree %s\n",
-		getenv("GIT_INDEX_FILE"),
-		sha1_to_hex(tree->object.sha1));
-#endif
 	int rc;
-	const char *argv[] = { "git-read-tree", NULL, NULL, };
+	struct object_list *trees = NULL;
+	struct unpack_trees_options opts;
+
 	if (cache_dirty)
 		die("read-tree with dirty cache");
-	argv[1] = sha1_to_hex(tree->object.sha1);
-	rc = run_command_v(2, argv);
-	return rc < 0 ? -1: rc;
+
+	memset(&opts, 0, sizeof(opts));
+	object_list_append(&tree->object, &trees);
+	rc = unpack_trees(trees, &opts);
+	cache_tree_free(&active_cache_tree);
+
+	if (rc == 0)
+		cache_dirty = 1;
+
+	return rc;
 }
 
-/*
- * TODO: this can be streamlined by refactoring builtin-read-tree.c
- */
-static int git_merge_trees(const char *update_arg,
+static int git_merge_trees(int index_only,
 			   struct tree *common,
 			   struct tree *head,
 			   struct tree *merge)
 {
-#if 0
-	fprintf(stderr, "GIT_INDEX_FILE='%s' git-read-tree %s -m %s %s %s\n",
-		getenv("GIT_INDEX_FILE"),
-		update_arg,
-		sha1_to_hex(common->object.sha1),
-		sha1_to_hex(head->object.sha1),
-		sha1_to_hex(merge->object.sha1));
-#endif
 	int rc;
-	const char *argv[] = {
-		"git-read-tree", NULL, "-m", NULL, NULL, NULL,
-		NULL,
-	};
-	if (cache_dirty)
-		flush_cache();
-	argv[1] = update_arg;
-	argv[3] = sha1_to_hex(common->object.sha1);
-	argv[4] = sha1_to_hex(head->object.sha1);
-	argv[5] = sha1_to_hex(merge->object.sha1);
-	rc = run_command_v(6, argv);
-	return rc < 0 ? -1: rc;
+	struct object_list *trees = NULL;
+	struct unpack_trees_options opts;
+
+	if (!cache_dirty) {
+		read_cache_from(current_index_file);
+		cache_dirty = 1;
+	}
+
+	memset(&opts, 0, sizeof(opts));
+	if (index_only)
+		opts.index_only = 1;
+	else
+		opts.update = 1;
+	opts.merge = 1;
+	opts.head_idx = 2;
+	opts.fn = threeway_merge;
+
+	object_list_append(&common->object, &trees);
+	object_list_append(&head->object, &trees);
+	object_list_append(&merge->object, &trees);
+
+	rc = unpack_trees(trees, &opts);
+	cache_tree_free(&active_cache_tree);
+
+	cache_dirty = 1;
+
+	return rc;
 }
 
-/*
- * TODO: this can be streamlined by refactoring builtin-write-tree.c
- */
 static struct tree *git_write_tree(void)
 {
-#if 0
-	fprintf(stderr, "GIT_INDEX_FILE='%s' git-write-tree\n",
-		getenv("GIT_INDEX_FILE"));
-#endif
-	FILE *fp;
-	int rc;
-	char buf[41];
-	unsigned char sha1[20];
-	int ch;
-	unsigned i = 0;
-	if (cache_dirty)
-		flush_cache();
-	fp = popen("git-write-tree 2>/dev/null", "r");
-	while ((ch = fgetc(fp)) != EOF)
-		if (i < sizeof(buf)-1 && ch >= '0' && ch <= 'f')
-			buf[i++] = ch;
-		else
-			break;
-	rc = pclose(fp);
-	if (rc == -1 || WEXITSTATUS(rc))
-		return NULL;
-	buf[i] = '\0';
-	if (get_sha1(buf, sha1) != 0)
-		return NULL;
-	return lookup_tree(sha1);
+	struct tree *result = NULL;
+
+	if (cache_dirty) {
+		unsigned i;
+		for (i = 0; i < active_nr; i++) {
+			struct cache_entry *ce = active_cache[i];
+			if (ce_stage(ce))
+				return NULL;
+		}
+	} else
+		read_cache_from(current_index_file);
+
+	if (!active_cache_tree)
+		active_cache_tree = cache_tree();
+
+	if (!cache_tree_fully_valid(active_cache_tree) &&
+			cache_tree_update(active_cache_tree,
+				active_cache, active_nr, 0, 0) < 0)
+		die("error building trees");
+
+	result = lookup_tree(active_cache_tree->sha1);
+
+	flush_cache();
+	cache_dirty = 0;
+
+	return result;
 }
 
 static int save_files_dirs(const unsigned char *sha1,
@@ -279,7 +283,7 @@ static int save_files_dirs(const unsigned char *sha1,
 		unsigned int mode, int stage)
 {
 	int len = strlen(path);
-	char *newpath = malloc(baselen + len + 1);
+	char *newpath = xmalloc(baselen + len + 1);
 	memcpy(newpath, base, baselen);
 	memcpy(newpath + baselen, path, len);
 	newpath[baselen + len] = '\0';
@@ -334,7 +338,7 @@ static struct path_list *get_unmerged(void)
 
 	unmerged->strdup_paths = 1;
 	if (!cache_dirty) {
-		read_cache_from(getenv("GIT_INDEX_FILE"));
+		read_cache_from(current_index_file);
 		cache_dirty++;
 	}
 	for (i = 0; i < active_nr; i++) {
@@ -351,7 +355,7 @@ static struct path_list *get_unmerged(void)
 		}
 		e = item->util;
 		e->stages[ce_stage(ce)].mode = ntohl(ce->ce_mode);
-		memcpy(e->stages[ce_stage(ce)].sha, ce->sha1, 20);
+		hashcpy(e->stages[ce_stage(ce)].sha, ce->sha1);
 	}
 
 	return unmerged;
@@ -451,7 +455,7 @@ static int remove_path(const char *name)
 	if (ret)
 		return ret;
 	len = strlen(name);
-	dirs = malloc(len+1);
+	dirs = xmalloc(len+1);
 	memcpy(dirs, name, len);
 	dirs[len] = '\0';
 	while ((slash = strrchr(name, '/'))) {
@@ -464,10 +468,6 @@ static int remove_path(const char *name)
 	return ret;
 }
 
-/*
- * TODO: once we no longer call external programs, we'd probably be better off
- * not setting / getting the environment variable GIT_INDEX_FILE all the time.
- */
 int remove_file(int clean, const char *path)
 {
 	int update_cache = index_only || clean;
@@ -475,7 +475,7 @@ int remove_file(int clean, const char *path)
 
 	if (update_cache) {
 		if (!cache_dirty)
-			read_cache_from(getenv("GIT_INDEX_FILE"));
+			read_cache_from(current_index_file);
 		cache_dirty++;
 		if (remove_file_from_cache(path))
 			return -1;
@@ -495,9 +495,9 @@ static char *unique_path(const char *path, const char *branch)
 	char *newpath = xmalloc(strlen(path) + 1 + strlen(branch) + 8 + 1);
 	int suffix = 0;
 	struct stat st;
-	char *p = newpath + strlen(newpath);
+	char *p = newpath + strlen(path);
 	strcpy(newpath, path);
-	strcat(newpath, "~");
+	*(p++) = '~';
 	strcpy(p, branch);
 	for (; *p; ++p)
 		if ('/' == *p)
@@ -513,8 +513,8 @@ static char *unique_path(const char *path, const char *branch)
 
 static int mkdir_p(const char *path, unsigned long mode)
 {
-	/* path points to cache entries, so strdup before messing with it */
-	char *buf = strdup(path);
+	/* path points to cache entries, so xstrdup before messing with it */
+	char *buf = xstrdup(path);
 	int result = safe_create_leading_directories(buf);
 	free(buf);
 	return result;
@@ -572,7 +572,7 @@ void update_file_flags(const unsigned char *sha,
 			flush_buffer(fd, buf, size);
 			close(fd);
 		} else if (S_ISLNK(mode)) {
-			char *lnk = malloc(size + 1);
+			char *lnk = xmalloc(size + 1);
 			memcpy(lnk, buf, size);
 			lnk[size] = '\0';
 			mkdir_p(path, 0777);
@@ -626,7 +626,7 @@ static char *git_unpack_file(const unsigned char *sha1, char *path)
 
 static struct merge_file_info merge_file(struct diff_filespec *o,
 		struct diff_filespec *a, struct diff_filespec *b,
-		const char *branch1Name, const char *branch2Name)
+		const char *branch1, const char *branch2)
 {
 	struct merge_file_info result;
 	result.merge = 0;
@@ -636,10 +636,10 @@ static struct merge_file_info merge_file(struct diff_filespec *o,
 		result.clean = 0;
 		if (S_ISREG(a->mode)) {
 			result.mode = a->mode;
-			memcpy(result.sha, a->sha1, 20);
+			hashcpy(result.sha, a->sha1);
 		} else {
 			result.mode = b->mode;
-			memcpy(result.sha, b->sha1, 20);
+			hashcpy(result.sha, b->sha1);
 		}
 	} else {
 		if (!sha_eq(a->sha1, o->sha1) && !sha_eq(b->sha1, o->sha1))
@@ -648,9 +648,9 @@ static struct merge_file_info merge_file(struct diff_filespec *o,
 		result.mode = a->mode == o->mode ? b->mode: a->mode;
 
 		if (sha_eq(a->sha1, o->sha1))
-			memcpy(result.sha, b->sha1, 20);
+			hashcpy(result.sha, b->sha1);
 		else if (sha_eq(b->sha1, o->sha1))
-			memcpy(result.sha, a->sha1, 20);
+			hashcpy(result.sha, a->sha1);
 		else if (S_ISREG(a->mode)) {
 			int code = 1, fd;
 			struct stat st;
@@ -659,7 +659,7 @@ static struct merge_file_info merge_file(struct diff_filespec *o,
 			char src2[PATH_MAX];
 			const char *argv[] = {
 				"merge", "-L", NULL, "-L", NULL, "-L", NULL,
-				src1, orig, src2,
+				NULL, NULL, NULL,
 				NULL
 			};
 			char *la, *lb, *lo;
@@ -668,15 +668,13 @@ static struct merge_file_info merge_file(struct diff_filespec *o,
 			git_unpack_file(a->sha1, src1);
 			git_unpack_file(b->sha1, src2);
 
-			argv[2] = la = strdup(mkpath("%s/%s", branch1Name, a->path));
-			argv[6] = lb = strdup(mkpath("%s/%s", branch2Name, b->path));
-			argv[4] = lo = strdup(mkpath("orig/%s", o->path));
+			argv[2] = la = xstrdup(mkpath("%s/%s", branch1, a->path));
+			argv[6] = lb = xstrdup(mkpath("%s/%s", branch2, b->path));
+			argv[4] = lo = xstrdup(mkpath("orig/%s", o->path));
+			argv[7] = src1;
+			argv[8] = orig;
+			argv[9] = src2,
 
-#if 0
-			printf("%s %s %s %s %s %s %s %s %s %s\n",
-			       argv[0], argv[1], argv[2], argv[3], argv[4],
-			       argv[5], argv[6], argv[7], argv[8], argv[9]);
-#endif
 			code = run_command_v(10, argv);
 
 			free(la);
@@ -701,7 +699,7 @@ static struct merge_file_info merge_file(struct diff_filespec *o,
 			if (!(S_ISLNK(a->mode) || S_ISLNK(b->mode)))
 				die("cannot merge modes?");
 
-			memcpy(result.sha, a->sha1, 20);
+			hashcpy(result.sha, a->sha1);
 
 			if (!sha_eq(a->sha1, b->sha1))
 				result.clean = 0;
@@ -804,8 +802,10 @@ static int process_renames(struct path_list *a_renames,
 		} else {
 			compare = strcmp(a_renames->items[i].path,
 					b_renames->items[j].path);
-			ren1 = a_renames->items[i++].util;
-			ren2 = b_renames->items[j++].util;
+			if (compare <= 0)
+				ren1 = a_renames->items[i++].util;
+			if (compare >= 0)
+				ren2 = b_renames->items[j++].util;
 		}
 
 		/* TODO: refactor, so that 1/2 are not needed */
@@ -891,11 +891,9 @@ static int process_renames(struct path_list *a_renames,
 
 			remove_file(1, ren1_src);
 
-			memcpy(src_other.sha1,
-					ren1->src_entry->stages[stage].sha, 20);
+			hashcpy(src_other.sha1, ren1->src_entry->stages[stage].sha);
 			src_other.mode = ren1->src_entry->stages[stage].mode;
-			memcpy(dst_other.sha1,
-					ren1->dst_entry->stages[stage].sha, 20);
+			hashcpy(dst_other.sha1, ren1->dst_entry->stages[stage].sha);
 			dst_other.mode = ren1->dst_entry->stages[stage].mode;
 
 			try_merge = 0;
@@ -980,13 +978,13 @@ static int process_renames(struct path_list *a_renames,
 
 static unsigned char *has_sha(const unsigned char *sha)
 {
-	return memcmp(sha, null_sha1, 20) == 0 ? NULL: (unsigned char *)sha;
+	return is_null_sha1(sha) ? NULL: (unsigned char *)sha;
 }
 
 /* Per entry merge function */
 static int process_entry(const char *path, struct stage_data *entry,
-			 const char *branch1Name,
-			 const char *branch2Name)
+			 const char *branch1,
+			 const char *branch2)
 {
 	/*
 	printf("processing entry, clean cache: %s\n", index_only ? "yes": "no");
@@ -1016,14 +1014,14 @@ static int process_entry(const char *path, struct stage_data *entry,
 			if (!a_sha) {
 				output("CONFLICT (delete/modify): %s deleted in %s "
 				       "and modified in %s. Version %s of %s left in tree.",
-				       path, branch1Name,
-				       branch2Name, branch2Name, path);
+				       path, branch1,
+				       branch2, branch2, path);
 				update_file(0, b_sha, b_mode, path);
 			} else {
 				output("CONFLICT (delete/modify): %s deleted in %s "
 				       "and modified in %s. Version %s of %s left in tree.",
-				       path, branch2Name,
-				       branch1Name, branch1Name, path);
+				       path, branch2,
+				       branch1, branch1, path);
 				update_file(0, a_sha, a_mode, path);
 			}
 		}
@@ -1038,14 +1036,14 @@ static int process_entry(const char *path, struct stage_data *entry,
 		const char *conf;
 
 		if (a_sha) {
-			add_branch = branch1Name;
-			other_branch = branch2Name;
+			add_branch = branch1;
+			other_branch = branch2;
 			mode = a_mode;
 			sha = a_sha;
 			conf = "file/directory";
 		} else {
-			add_branch = branch2Name;
-			other_branch = branch1Name;
+			add_branch = branch2;
+			other_branch = branch1;
 			mode = b_mode;
 			sha = b_sha;
 			conf = "directory/file";
@@ -1079,8 +1077,8 @@ static int process_entry(const char *path, struct stage_data *entry,
 		} else {
 			const char *new_path1, *new_path2;
 			clean_merge = 0;
-			new_path1 = unique_path(path, branch1Name);
-			new_path2 = unique_path(path, branch2Name);
+			new_path1 = unique_path(path, branch1);
+			new_path2 = unique_path(path, branch2);
 			output("CONFLICT (add/add): File %s added non-identically "
 			       "in both branches. Adding as %s and %s instead.",
 			       path, new_path1, new_path2);
@@ -1096,15 +1094,15 @@ static int process_entry(const char *path, struct stage_data *entry,
 
 		output("Auto-merging %s", path);
 		o.path = a.path = b.path = (char *)path;
-		memcpy(o.sha1, o_sha, 20);
+		hashcpy(o.sha1, o_sha);
 		o.mode = o_mode;
-		memcpy(a.sha1, a_sha, 20);
+		hashcpy(a.sha1, a_sha);
 		a.mode = a_mode;
-		memcpy(b.sha1, b_sha, 20);
+		hashcpy(b.sha1, b_sha);
 		b.mode = b_mode;
 
 		mfi = merge_file(&o, &a, &b,
-				 branch1Name, branch2Name);
+				 branch1, branch2);
 
 		if (mfi.clean)
 			update_file(1, mfi.sha, mfi.mode, path);
@@ -1130,8 +1128,8 @@ static int process_entry(const char *path, struct stage_data *entry,
 static int merge_trees(struct tree *head,
 		       struct tree *merge,
 		       struct tree *common,
-		       const char *branch1Name,
-		       const char *branch2Name,
+		       const char *branch1,
+		       const char *branch2,
 		       struct tree **result)
 {
 	int code, clean;
@@ -1141,7 +1139,7 @@ static int merge_trees(struct tree *head,
 		return 1;
 	}
 
-	code = git_merge_trees(index_only ? "-i": "-u", common, head, merge);
+	code = git_merge_trees(index_only, common, head, merge);
 
 	if (code != 0)
 		die("merging of trees %s and %s failed",
@@ -1162,13 +1160,13 @@ static int merge_trees(struct tree *head,
 		re_head  = get_renames(head, common, head, merge, entries);
 		re_merge = get_renames(merge, common, head, merge, entries);
 		clean = process_renames(re_head, re_merge,
-				branch1Name, branch2Name);
+				branch1, branch2);
 		for (i = 0; i < entries->nr; i++) {
 			const char *path = entries->items[i].path;
 			struct stage_data *e = entries->items[i].util;
 			if (e->processed)
 				continue;
-			if (!process_entry(path, e, branch1Name, branch2Name))
+			if (!process_entry(path, e, branch1, branch2))
 				clean = 0;
 		}
 
@@ -1191,6 +1189,17 @@ static int merge_trees(struct tree *head,
 	return clean;
 }
 
+static struct commit_list *reverse_commit_list(struct commit_list *list)
+{
+	struct commit_list *next = NULL, *current, *backup;
+	for (current = list; current; current = backup) {
+		backup = current->next;
+		current->next = next;
+		next = current;
+	}
+	return next;
+}
+
 /*
  * Merge the commits h1 and h2, return the resulting virtual
  * commit object and a flag indicating the cleaness of the merge.
@@ -1198,8 +1207,8 @@ static int merge_trees(struct tree *head,
 static
 int merge(struct commit *h1,
 			  struct commit *h2,
-			  const char *branch1Name,
-			  const char *branch2Name,
+			  const char *branch1,
+			  const char *branch2,
 			  int call_depth /* =0 */,
 			  struct commit *ancestor /* =None */,
 			  struct commit **result)
@@ -1216,13 +1225,22 @@ int merge(struct commit *h1,
 	if (ancestor)
 		commit_list_insert(ancestor, &ca);
 	else
-		ca = get_merge_bases(h1, h2, 1);
+		ca = reverse_commit_list(get_merge_bases(h1, h2, 1));
 
 	output("found %u common ancestor(s):", commit_list_count(ca));
 	for (iter = ca; iter; iter = iter->next)
 		output_commit_title(iter->item);
 
 	merged_common_ancestors = pop_commit(&ca);
+	if (merged_common_ancestors == NULL) {
+		/* if there is no common ancestor, make an empty tree */
+		struct tree *tree = xcalloc(1, sizeof(struct tree));
+
+		tree->object.parsed = 1;
+		tree->object.type = OBJ_TREE;
+		hash_sha1_file(NULL, 0, tree_type, tree->object.sha1);
+		merged_common_ancestors = make_virtual_commit(tree, "ancestor");
+	}
 
 	for (iter = ca; iter; iter = iter->next) {
 		output_indent = call_depth + 1;
@@ -1255,7 +1273,7 @@ int merge(struct commit *h1,
 	}
 
 	clean = merge_trees(h1->tree, h2->tree, merged_common_ancestors->tree,
-			    branch1Name, branch2Name, &mrtree);
+			    branch1, branch2, &mrtree);
 
 	if (!ancestor && (clean || index_only)) {
 		*result = make_virtual_commit(mrtree, "merged tree");
@@ -1293,9 +1311,9 @@ int main(int argc, char *argv[])
 	original_index_file = getenv("GIT_INDEX_FILE");
 
 	if (!original_index_file)
-		original_index_file = strdup(git_path("index"));
+		original_index_file = xstrdup(git_path("index"));
 
-	temporary_index_file = strdup(git_path("mrg-rcrsv-tmp-idx"));
+	temporary_index_file = xstrdup(git_path("mrg-rcrsv-tmp-idx"));
 
 	if (argc < 4)
 		die("Usage: %s <base>... -- <head> <remote> ...\n", argv[0]);