mirror of
https://github.com/git/git
synced 2024-08-24 18:26:02 +00:00
Merge branch 'lt/merge-tree'
* lt/merge-tree: Improved three-way blob merging code Prepare "git-merge-tree" for future work xdiff: generate "anti-diffs" aka what is common to two files
This commit is contained in:
Junio C Hamano
commit
096b173234
2
Makefile
2
Makefile
|
|
@ -222,7 +222,7 @@ LIB_OBJS = \
|
|||
server-info.o setup.o sha1_file.o sha1_name.o strbuf.o \
|
||||
tag.o tree.o usage.o config.o environment.o ctype.o copy.o \
|
||||
fetch-clone.o revision.o pager.o tree-walk.o xdiff-interface.o \
|
||||
alloc.o $(DIFF_OBJS)
|
||||
alloc.o merge-file.o $(DIFF_OBJS)
|
||||
|
||||
BUILTIN_OBJS = \
|
||||
builtin-log.o builtin-help.o builtin-count.o builtin-diff.o builtin-push.o \
|
||||
|
|
|
|||
166
merge-file.c
Normal file
166
merge-file.c
Normal file
|
|
@ -0,0 +1,166 @@
|
|||
#include "cache.h"
|
||||
#include "run-command.h"
|
||||
#include "xdiff-interface.h"
|
||||
#include "blob.h"
|
||||
|
||||
static void rm_temp_file(const char *filename)
|
||||
{
|
||||
unlink(filename);
|
||||
free((void *)filename);
|
||||
}
|
||||
|
||||
static const char *write_temp_file(mmfile_t *f)
|
||||
{
|
||||
int fd;
|
||||
const char *tmp = getenv("TMPDIR");
|
||||
char *filename;
|
||||
|
||||
if (!tmp)
|
||||
tmp = "/tmp";
|
||||
filename = mkpath("%s/%s", tmp, "git-tmp-XXXXXX");
|
||||
fd = mkstemp(filename);
|
||||
if (fd < 0)
|
||||
return NULL;
|
||||
filename = strdup(filename);
|
||||
if (f->size != xwrite(fd, f->ptr, f->size)) {
|
||||
rm_temp_file(filename);
|
||||
return NULL;
|
||||
}
|
||||
close(fd);
|
||||
return filename;
|
||||
}
|
||||
|
||||
static void *read_temp_file(const char *filename, unsigned long *size)
|
||||
{
|
||||
struct stat st;
|
||||
char *buf = NULL;
|
||||
int fd = open(filename, O_RDONLY);
|
||||
if (fd < 0)
|
||||
return NULL;
|
||||
if (!fstat(fd, &st)) {
|
||||
*size = st.st_size;
|
||||
buf = xmalloc(st.st_size);
|
||||
if (st.st_size != xread(fd, buf, st.st_size)) {
|
||||
free(buf);
|
||||
buf = NULL;
|
||||
}
|
||||
}
|
||||
close(fd);
|
||||
return buf;
|
||||
}
|
||||
|
||||
static int fill_mmfile_blob(mmfile_t *f, struct blob *obj)
|
||||
{
|
||||
void *buf;
|
||||
unsigned long size;
|
||||
char type[20];
|
||||
|
||||
buf = read_sha1_file(obj->object.sha1, type, &size);
|
||||
if (!buf)
|
||||
return -1;
|
||||
if (strcmp(type, blob_type))
|
||||
return -1;
|
||||
f->ptr = buf;
|
||||
f->size = size;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void free_mmfile(mmfile_t *f)
|
||||
{
|
||||
free(f->ptr);
|
||||
}
|
||||
|
||||
static void *three_way_filemerge(mmfile_t *base, mmfile_t *our, mmfile_t *their, unsigned long *size)
|
||||
{
|
||||
void *res;
|
||||
const char *t1, *t2, *t3;
|
||||
|
||||
t1 = write_temp_file(base);
|
||||
t2 = write_temp_file(our);
|
||||
t3 = write_temp_file(their);
|
||||
res = NULL;
|
||||
if (t1 && t2 && t3) {
|
||||
int code = run_command("merge", t2, t1, t3, NULL);
|
||||
if (!code || code == -1)
|
||||
res = read_temp_file(t2, size);
|
||||
}
|
||||
rm_temp_file(t1);
|
||||
rm_temp_file(t2);
|
||||
rm_temp_file(t3);
|
||||
return res;
|
||||
}
|
||||
|
||||
static int common_outf(void *priv_, mmbuffer_t *mb, int nbuf)
|
||||
{
|
||||
int i;
|
||||
mmfile_t *dst = priv_;
|
||||
|
||||
for (i = 0; i < nbuf; i++) {
|
||||
memcpy(dst->ptr + dst->size, mb[i].ptr, mb[i].size);
|
||||
dst->size += mb[i].size;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int generate_common_file(mmfile_t *res, mmfile_t *f1, mmfile_t *f2)
|
||||
{
|
||||
unsigned long size = f1->size < f2->size ? f1->size : f2->size;
|
||||
void *ptr = xmalloc(size);
|
||||
xpparam_t xpp;
|
||||
xdemitconf_t xecfg;
|
||||
xdemitcb_t ecb;
|
||||
|
||||
xpp.flags = XDF_NEED_MINIMAL;
|
||||
xecfg.ctxlen = 3;
|
||||
xecfg.flags = XDL_EMIT_COMMON;
|
||||
ecb.outf = common_outf;
|
||||
|
||||
res->ptr = ptr;
|
||||
res->size = 0;
|
||||
|
||||
ecb.priv = res;
|
||||
return xdl_diff(f1, f2, &xpp, &xecfg, &ecb);
|
||||
}
|
||||
|
||||
void *merge_file(struct blob *base, struct blob *our, struct blob *their, unsigned long *size)
|
||||
{
|
||||
void *res = NULL;
|
||||
mmfile_t f1, f2, common;
|
||||
|
||||
/*
|
||||
* Removed in either branch?
|
||||
*
|
||||
* NOTE! This depends on the caller having done the
|
||||
* proper warning about removing a file that got
|
||||
* modified in the other branch!
|
||||
*/
|
||||
if (!our || !their) {
|
||||
char type[20];
|
||||
if (base)
|
||||
return NULL;
|
||||
if (!our)
|
||||
our = their;
|
||||
return read_sha1_file(our->object.sha1, type, size);
|
||||
}
|
||||
|
||||
if (fill_mmfile_blob(&f1, our) < 0)
|
||||
goto out_no_mmfile;
|
||||
if (fill_mmfile_blob(&f2, their) < 0)
|
||||
goto out_free_f1;
|
||||
|
||||
if (base) {
|
||||
if (fill_mmfile_blob(&common, base) < 0)
|
||||
goto out_free_f2_f1;
|
||||
} else {
|
||||
if (generate_common_file(&common, &f1, &f2) < 0)
|
||||
goto out_free_f2_f1;
|
||||
}
|
||||
res = three_way_filemerge(&common, &f1, &f2, size);
|
||||
free_mmfile(&common);
|
||||
out_free_f2_f1:
|
||||
free_mmfile(&f2);
|
||||
out_free_f1:
|
||||
free_mmfile(&f1);
|
||||
out_no_mmfile:
|
||||
return res;
|
||||
}
|
||||
207
merge-tree.c
207
merge-tree.c
|
|
@ -1,11 +1,152 @@
|
|||
#include "cache.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 const char *explanation(struct merge_list *entry)
|
||||
{
|
||||
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 (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)
|
||||
{
|
||||
char type[20];
|
||||
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;
|
||||
}
|
||||
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);
|
||||
}
|
||||
|
||||
static void *origin(struct merge_list *entry, unsigned long *size)
|
||||
{
|
||||
char type[20];
|
||||
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 show_diff(struct merge_list *entry)
|
||||
{
|
||||
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 void show_result_list(struct merge_list *entry)
|
||||
{
|
||||
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 show_result(void)
|
||||
{
|
||||
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 */
|
||||
static int same_entry(struct name_entry *a, struct name_entry *b)
|
||||
{
|
||||
|
|
@ -15,24 +156,34 @@ static int same_entry(struct name_entry *a, struct name_entry *b)
|
|||
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)
|
||||
{
|
||||
struct merge_list *orig, *final;
|
||||
const char *path;
|
||||
|
||||
/* If it's already branch1, don't bother showing it */
|
||||
if (!branch1)
|
||||
return;
|
||||
|
||||
printf("0 %06o->%06o %s->%s %s%s\n",
|
||||
branch1->mode, result->mode,
|
||||
sha1_to_hex_zero(branch1->sha1),
|
||||
sha1_to_hex_zero(result->sha1),
|
||||
base, result->path);
|
||||
path = strdup(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])
|
||||
|
|
@ -71,16 +222,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 = strdup(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);
|
||||
|
||||
/*
|
||||
* 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);
|
||||
|
||||
add_merge_entry(entry);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -172,5 +347,7 @@ int main(int argc, char **argv)
|
|||
free(buf1);
|
||||
free(buf2);
|
||||
free(buf3);
|
||||
|
||||
show_result();
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@ extern "C" {
|
|||
#define XDL_PATCH_IGNOREBSPACE (1 << 8)
|
||||
|
||||
#define XDL_EMIT_FUNCNAMES (1 << 0)
|
||||
#define XDL_EMIT_COMMON (1 << 1)
|
||||
|
||||
#define XDL_MMB_READONLY (1 << 0)
|
||||
|
||||
|
|
|
|||
|
|
@ -100,6 +100,21 @@ static void xdl_find_func(xdfile_t *xf, long i, char *buf, long sz, long *ll) {
|
|||
}
|
||||
|
||||
|
||||
int xdl_emit_common(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb,
|
||||
xdemitconf_t const *xecfg) {
|
||||
xdfile_t *xdf = &xe->xdf1;
|
||||
const char *rchg = xdf->rchg;
|
||||
long ix;
|
||||
|
||||
for (ix = 0; ix < xdf->nrec; ix++) {
|
||||
if (rchg[ix])
|
||||
continue;
|
||||
if (xdl_emit_record(xdf, ix, "", ecb))
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int xdl_emit_diff(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb,
|
||||
xdemitconf_t const *xecfg) {
|
||||
long s1, s2, e1, e2, lctx;
|
||||
|
|
@ -107,6 +122,9 @@ int xdl_emit_diff(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb,
|
|||
char funcbuf[40];
|
||||
long funclen = 0;
|
||||
|
||||
if (xecfg->flags & XDL_EMIT_COMMON)
|
||||
return xdl_emit_common(xe, xscr, ecb, xecfg);
|
||||
|
||||
for (xch = xche = xscr; xch; xch = xche->next) {
|
||||
xche = xdl_get_hunk(xch, xecfg);
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue