X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=merge-tree.c;h=3b8d9e6887ae051bf61cc0833f97d83bb47a0bae;hb=384f122b7c6dd2b52cc6029afee16560c38850ae;hp=768d83a7c23d948dc85ada30a5226078d105ab08;hpb=816c02ce8ecddce065e83db9f4ecb78f6b0e23dc;p=git.git

diff --git a/merge-tree.c b/merge-tree.c
index 768d83a7c..3b8d9e688 100644
--- a/merge-tree.c
+++ b/merge-tree.c
@@ -1,49 +1,150 @@
 #include "cache.h"
-#include "diff.h"
+#include "tree-walk.h"
+#include "xdiff-interface.h"
+#include "blob.h"
 
 static const char merge_tree_usage[] = "git-merge-tree <base-tree> <branch1> <branch2>";
 static int resolve_directories = 1;
 
+struct merge_list {
+	struct merge_list *next;
+	struct merge_list *link;	/* other stages for this object */
+
+	unsigned int stage : 2,
+		     flags : 30;
+	unsigned int mode;
+	const char *path;
+	struct blob *blob;
+};
+
+static struct merge_list *merge_result, **merge_result_end = &merge_result;
+
+static void add_merge_entry(struct merge_list *entry)
+{
+	*merge_result_end = entry;
+	merge_result_end = &entry->next;
+}
+
 static void merge_trees(struct tree_desc t[3], const char *base);
 
-static void *fill_tree_descriptor(struct tree_desc *desc, const unsigned char *sha1)
+static const char *explanation(struct merge_list *entry)
 {
-	unsigned long size = 0;
-	void *buf = NULL;
+	switch (entry->stage) {
+	case 0:
+		return "merged";
+	case 3:
+		return "added in remote";
+	case 2:
+		if (entry->link)
+			return "added in both";
+		return "added in local";
+	}
+
+	/* Existed in base */
+	entry = entry->link;
+	if (!entry)
+		return "removed in both";
+
+	if (entry->link)
+		return "changed in both";
 
-	if (sha1) {
-		buf = read_object_with_reference(sha1, "tree", &size, NULL);
-		if (!buf)
-			die("unable to read tree %s", sha1_to_hex(sha1));
+	if (entry->stage == 3)
+		return "removed in local";
+	return "removed in remote";
+}
+
+extern void *merge_file(struct blob *, struct blob *, struct blob *, unsigned long *);
+
+static void *result(struct merge_list *entry, unsigned long *size)
+{
+	enum object_type type;
+	struct blob *base, *our, *their;
+
+	if (!entry->stage)
+		return read_sha1_file(entry->blob->object.sha1, &type, size);
+	base = NULL;
+	if (entry->stage == 1) {
+		base = entry->blob;
+		entry = entry->link;
 	}
-	desc->size = size;
-	desc->buf = buf;
-	return buf;
+	our = NULL;
+	if (entry && entry->stage == 2) {
+		our = entry->blob;
+		entry = entry->link;
+	}
+	their = NULL;
+	if (entry)
+		their = entry->blob;
+	return merge_file(base, our, their, size);
 }
 
-struct name_entry {
-	const unsigned char *sha1;
-	const char *path;
-	unsigned int mode;
-	int pathlen;
-};
+static void *origin(struct merge_list *entry, unsigned long *size)
+{
+	enum object_type type;
+	while (entry) {
+		if (entry->stage == 2)
+			return read_sha1_file(entry->blob->object.sha1, &type, size);
+		entry = entry->link;
+	}
+	return NULL;
+}
+
+static int show_outf(void *priv_, mmbuffer_t *mb, int nbuf)
+{
+	int i;
+	for (i = 0; i < nbuf; i++)
+		printf("%.*s", (int) mb[i].size, mb[i].ptr);
+	return 0;
+}
 
-static void entry_clear(struct name_entry *a)
+static void show_diff(struct merge_list *entry)
 {
-	memset(a, 0, sizeof(*a));
+	unsigned long size;
+	mmfile_t src, dst;
+	xpparam_t xpp;
+	xdemitconf_t xecfg;
+	xdemitcb_t ecb;
+
+	xpp.flags = XDF_NEED_MINIMAL;
+	xecfg.ctxlen = 3;
+	xecfg.flags = 0;
+	ecb.outf = show_outf;
+	ecb.priv = NULL;
+
+	src.ptr = origin(entry, &size);
+	if (!src.ptr)
+		size = 0;
+	src.size = size;
+	dst.ptr = result(entry, &size);
+	if (!dst.ptr)
+		size = 0;
+	dst.size = size;
+	xdl_diff(&src, &dst, &xpp, &xecfg, &ecb);
+	free(src.ptr);
+	free(dst.ptr);
 }
 
-static int entry_compare(struct name_entry *a, struct name_entry *b)
+static void show_result_list(struct merge_list *entry)
 {
-	return base_name_compare(
-			a->path, a->pathlen, a->mode,
-			b->path, b->pathlen, b->mode);
+	printf("%s\n", explanation(entry));
+	do {
+		struct merge_list *link = entry->link;
+		static const char *desc[4] = { "result", "base", "our", "their" };
+		printf("  %-6s %o %s %s\n", desc[entry->stage], entry->mode, sha1_to_hex(entry->blob->object.sha1), entry->path);
+		entry = link;
+	} while (entry);
 }
 
-static void entry_extract(struct tree_desc *t, struct name_entry *a)
+static void show_result(void)
 {
-	a->sha1 = tree_entry_extract(t, &a->path, &a->mode);
-	a->pathlen = strlen(a->path);
+	struct merge_list *walk;
+
+	walk = merge_result;
+	while (walk) {
+		show_result_list(walk);
+		show_diff(walk);
+		walk = walk->next;
+	}
 }
 
 /* An empty entry never compares same, not even to another empty entry */
@@ -51,35 +152,43 @@ static int same_entry(struct name_entry *a, struct name_entry *b)
 {
 	return	a->sha1 &&
 		b->sha1 &&
-		!memcmp(a->sha1, b->sha1, 20) &&
+		!hashcmp(a->sha1, b->sha1) &&
 		a->mode == b->mode;
 }
 
-static const char *sha1_to_hex_zero(const unsigned char *sha1)
+static struct merge_list *create_entry(unsigned stage, unsigned mode, const unsigned char *sha1, const char *path)
 {
-	if (sha1)
-		return sha1_to_hex(sha1);
-	return "0000000000000000000000000000000000000000";
+	struct merge_list *res = xmalloc(sizeof(*res));
+
+	memset(res, 0, sizeof(*res));
+	res->stage = stage;
+	res->path = path;
+	res->mode = mode;
+	res->blob = lookup_blob(sha1);
+	return res;
 }
 
 static void resolve(const char *base, struct name_entry *branch1, struct name_entry *result)
 {
-	char branch1_sha1[50];
+	struct merge_list *orig, *final;
+	const char *path;
 
 	/* If it's already branch1, don't bother showing it */
 	if (!branch1)
 		return;
-	memcpy(branch1_sha1, sha1_to_hex_zero(branch1->sha1), 41);
 
-	printf("0 %06o->%06o %s->%s %s%s\n",
-		branch1->mode, result->mode,
-		branch1_sha1, sha1_to_hex_zero(result->sha1),
-		base, result->path);
+	path = xstrdup(mkpath("%s%s", base, result->path));
+	orig = create_entry(2, branch1->mode, branch1->sha1, path);
+	final = create_entry(0, result->mode, result->sha1, path);
+
+	final->link = orig;
+
+	add_merge_entry(final);
 }
 
 static int unresolved_directory(const char *base, struct name_entry n[3])
 {
-	int baselen;
+	int baselen, pathlen;
 	char *newbase;
 	struct name_entry *p;
 	struct tree_desc t[3];
@@ -96,10 +205,11 @@ static int unresolved_directory(const char *base, struct name_entry n[3])
 	if (!S_ISDIR(p->mode))
 		return 0;
 	baselen = strlen(base);
-	newbase = xmalloc(baselen + p->pathlen + 2);
+	pathlen = tree_entry_len(p->path, p->sha1);
+	newbase = xmalloc(baselen + pathlen + 2);
 	memcpy(newbase, base, baselen);
-	memcpy(newbase + baselen, p->path, p->pathlen);
-	memcpy(newbase + baselen + p->pathlen, "/", 2);
+	memcpy(newbase + baselen, p->path, pathlen);
+	memcpy(newbase + baselen + pathlen, "/", 2);
 
 	buf0 = fill_tree_descriptor(t+0, n[0].sha1);
 	buf1 = fill_tree_descriptor(t+1, n[1].sha1);
@@ -113,70 +223,40 @@ static int unresolved_directory(const char *base, struct name_entry n[3])
 	return 1;
 }
 
+
+static struct merge_list *link_entry(unsigned stage, const char *base, struct name_entry *n, struct merge_list *entry)
+{
+	const char *path;
+	struct merge_list *link;
+
+	if (!n->mode)
+		return entry;
+	if (entry)
+		path = entry->path;
+	else
+		path = xstrdup(mkpath("%s%s", base, n->path));
+	link = create_entry(stage, n->mode, n->sha1, path);
+	link->link = entry;
+	return link;
+}
+
 static void unresolved(const char *base, struct name_entry n[3])
 {
+	struct merge_list *entry = NULL;
+
 	if (unresolved_directory(base, n))
 		return;
-	if (n[0].sha1)
-		printf("1 %06o %s %s%s\n", n[0].mode, sha1_to_hex(n[0].sha1), base, n[0].path);
-	if (n[1].sha1)
-		printf("2 %06o %s %s%s\n", n[1].mode, sha1_to_hex(n[1].sha1), base, n[1].path);
-	if (n[2].sha1)
-		printf("3 %06o %s %s%s\n", n[2].mode, sha1_to_hex(n[2].sha1), base, n[2].path);
-}
 
-typedef void (*traverse_callback_t)(int n, unsigned long mask, struct name_entry *entry, const char *base);
+	/*
+	 * Do them in reverse order so that the resulting link
+	 * list has the stages in order - link_entry adds new
+	 * links at the front.
+	 */
+	entry = link_entry(3, base, n + 2, entry);
+	entry = link_entry(2, base, n + 1, entry);
+	entry = link_entry(1, base, n + 0, entry);
 
-static void traverse_trees(int n, struct tree_desc *t, const char *base, traverse_callback_t callback)
-{
-	struct name_entry *entry = xmalloc(n*sizeof(*entry));
-
-	for (;;) {
-		struct name_entry entry[3];
-		unsigned long mask = 0;
-		int i, last;
-
-		last = -1;
-		for (i = 0; i < n; i++) {
-			if (!t[i].size)
-				continue;
-			entry_extract(t+i, entry+i);
-			if (last >= 0) {
-				int cmp = entry_compare(entry+i, entry+last);
-
-				/*
-				 * Is the new name bigger than the old one?
-				 * Ignore it
-				 */
-				if (cmp > 0)
-					continue;
-				/*
-				 * Is the new name smaller than the old one?
-				 * Ignore all old ones
-				 */
-				if (cmp < 0)
-					mask = 0;
-			}
-			mask |= 1ul << i;
-			last = i;
-		}
-		if (!mask)
-			break;
-
-		/*
-		 * Update the tree entries we've walked, and clear
-		 * all the unused name-entries.
-		 */
-		for (i = 0; i < n; i++) {
-			if (mask & (1ul << i)) {
-				update_tree_entry(t+i);
-				continue;
-			}
-			entry_clear(entry + i);
-		}
-		callback(n, mask, entry, base);
-	}
-	free(entry);
+	add_merge_entry(entry);
 }
 
 /*
@@ -245,7 +325,7 @@ static void *get_tree_descriptor(struct tree_desc *desc, const char *rev)
 	unsigned char sha1[20];
 	void *buf;
 
-	if (get_sha1(rev, sha1) < 0)
+	if (get_sha1(rev, sha1))
 		die("unknown rev %s", rev);
 	buf = fill_tree_descriptor(desc, sha1);
 	if (!buf)
@@ -258,9 +338,11 @@ int main(int argc, char **argv)
 	struct tree_desc t[3];
 	void *buf1, *buf2, *buf3;
 
-	if (argc < 4)
+	if (argc != 4)
 		usage(merge_tree_usage);
 
+	setup_git_directory();
+
 	buf1 = get_tree_descriptor(t+0, argv[1]);
 	buf2 = get_tree_descriptor(t+1, argv[2]);
 	buf3 = get_tree_descriptor(t+2, argv[3]);
@@ -268,5 +350,7 @@ int main(int argc, char **argv)
 	free(buf1);
 	free(buf2);
 	free(buf3);
+
+	show_result();
 	return 0;
 }