/* * Low level 3-way in-core file merge. * * Copyright (c) 2007 Junio C Hamano */ #include "cache.h" #include "attr.h" #include "xdiff-interface.h" #include "run-command.h" #include "ll-merge.h" struct ll_merge_driver; typedef int (*ll_merge_fn)(const struct ll_merge_driver *, mmbuffer_t *result, const char *path, mmfile_t *orig, const char *orig_name, mmfile_t *src1, const char *name1, mmfile_t *src2, const char *name2, const struct ll_merge_options *opts, int marker_size); struct ll_merge_driver { const char *name; const char *description; ll_merge_fn fn; const char *recursive; struct ll_merge_driver *next; char *cmdline; }; /* * Built-in low-levels */ static int ll_binary_merge(const struct ll_merge_driver *drv_unused, mmbuffer_t *result, const char *path, mmfile_t *orig, const char *orig_name, mmfile_t *src1, const char *name1, mmfile_t *src2, const char *name2, const struct ll_merge_options *opts, int marker_size) { mmfile_t *stolen; assert(opts); /* * The tentative merge result is the or common ancestor for an internal merge. */ if (opts->virtual_ancestor) { stolen = orig; } else { switch (opts->variant) { default: warning("Cannot merge binary files: %s (%s vs. %s)", path, name1, name2); /* fallthru */ case XDL_MERGE_FAVOR_OURS: stolen = src1; break; case XDL_MERGE_FAVOR_THEIRS: stolen = src2; break; } } result->ptr = stolen->ptr; result->size = stolen->size; stolen->ptr = NULL; /* * With -Xtheirs or -Xours, we have cleanly merged; * otherwise we got a conflict. */ return (opts->variant ? 0 : 1); } static int ll_xdl_merge(const struct ll_merge_driver *drv_unused, mmbuffer_t *result, const char *path, mmfile_t *orig, const char *orig_name, mmfile_t *src1, const char *name1, mmfile_t *src2, const char *name2, const struct ll_merge_options *opts, int marker_size) { xmparam_t xmp; assert(opts); if (buffer_is_binary(orig->ptr, orig->size) || buffer_is_binary(src1->ptr, src1->size) || buffer_is_binary(src2->ptr, src2->size)) { return ll_binary_merge(drv_unused, result, path, orig, orig_name, src1, name1, src2, name2, opts, marker_size); } memset(&xmp, 0, sizeof(xmp)); xmp.level = XDL_MERGE_ZEALOUS; xmp.favor = opts->variant; xmp.xpp.flags = opts->xdl_opts; if (git_xmerge_style >= 0) xmp.style = git_xmerge_style; if (marker_size > 0) xmp.marker_size = marker_size; xmp.ancestor = orig_name; xmp.file1 = name1; xmp.file2 = name2; return xdl_merge(orig, src1, src2, &xmp, result); } static int ll_union_merge(const struct ll_merge_driver *drv_unused, mmbuffer_t *result, const char *path_unused, mmfile_t *orig, const char *orig_name, mmfile_t *src1, const char *name1, mmfile_t *src2, const char *name2, const struct ll_merge_options *opts, int marker_size) { /* Use union favor */ struct ll_merge_options o; assert(opts); o = *opts; o.variant = XDL_MERGE_FAVOR_UNION; return ll_xdl_merge(drv_unused, result, path_unused, orig, NULL, src1, NULL, src2, NULL, &o, marker_size); } #define LL_BINARY_MERGE 0 #define LL_TEXT_MERGE 1 #define LL_UNION_MERGE 2 static struct ll_merge_driver ll_merge_drv[] = { { "binary", "built-in binary merge", ll_binary_merge }, { "text", "built-in 3-way text merge", ll_xdl_merge }, { "union", "built-in union merge", ll_union_merge }, }; static void create_temp(mmfile_t *src, char *path) { int fd; strcpy(path, ".merge_file_XXXXXX"); fd = xmkstemp(path); if (write_in_full(fd, src->ptr, src->size) != src->size) die_errno("unable to write temp-file"); close(fd); } /* * User defined low-level merge driver support. */ static int ll_ext_merge(const struct ll_merge_driver *fn, mmbuffer_t *result, const char *path, mmfile_t *orig, const char *orig_name, mmfile_t *src1, const char *name1, mmfile_t *src2, const char *name2, const struct ll_merge_options *opts, int marker_size) { char temp[4][50]; struct strbuf cmd = STRBUF_INIT; struct strbuf_expand_dict_entry dict[5]; const char *args[] = { NULL, NULL }; int status, fd, i; struct stat st; assert(opts); dict[0].placeholder = "O"; dict[0].value = temp[0]; dict[1].placeholder = "A"; dict[1].value = temp[1]; dict[2].placeholder = "B"; dict[2].value = temp[2]; dict[3].placeholder = "L"; dict[3].value = temp[3]; dict[4].placeholder = NULL; dict[4].value = NULL; if (fn->cmdline == NULL) die("custom merge driver %s lacks command line.", fn->name); result->ptr = NULL; result->size = 0; create_temp(orig, temp[0]); create_temp(src1, temp[1]); create_temp(src2, temp[2]); sprintf(temp[3], "%d", marker_size); strbuf_expand(&cmd, fn->cmdline, strbuf_expand_dict_cb, &dict); args[0] = cmd.buf; status = run_command_v_opt(args, RUN_USING_SHELL); fd = open(temp[1], O_RDONLY); if (fd < 0) goto bad; if (fstat(fd, &st)) goto close_bad; result->size = st.st_size; result->ptr = xmalloc(result->size + 1); if (read_in_full(fd, result->ptr, result->size) != result->size) { free(result->ptr); result->ptr = NULL; result->size = 0; } close_bad: close(fd); bad: for (i = 0; i < 3; i++) unlink_or_warn(temp[i]); strbuf_release(&cmd); return status; } /* * merge.default and merge.driver configuration items */ static struct ll_merge_driver *ll_user_merge, **ll_user_merge_tail; static const char *default_ll_merge; static int read_merge_config(const char *var, const char *value, void *cb) { struct ll_merge_driver *fn; const char *key, *name; int namelen; if (!strcmp(var, "merge.default")) { if (value) default_ll_merge = xstrdup(value); return 0; } /* * We are not interested in anything but "merge.<name>.variable"; * especially, we do not want to look at variables such as * "merge.summary", "merge.tool", and "merge.verbosity". */ if (parse_config_key(var, "merge", &name, &namelen, &key) < 0 || !name) return 0; /* * Find existing one as we might be processing merge.<name>.var2 * after seeing merge.<name>.var1. */ for (fn = ll_user_merge; fn; fn = fn->next) if (!strncmp(fn->name, name, namelen) && !fn->name[namelen]) break; if (!fn) { fn = xcalloc(1, sizeof(struct ll_merge_driver)); fn->name = xmemdupz(name, namelen); fn->fn = ll_ext_merge; *ll_user_merge_tail = fn; ll_user_merge_tail = &(fn->next); } if (!strcmp("name", key)) { if (!value) return error("%s: lacks value", var); fn->description = xstrdup(value); return 0; } if (!strcmp("driver", key)) { if (!value) return error("%s: lacks value", var); /* * merge.<name>.driver specifies the command line: * * command-line * * The command-line will be interpolated with the following * tokens and is given to the shell: * * %O - temporary file name for the merge base. * %A - temporary file name for our version. * %B - temporary file name for the other branches' version. * %L - conflict marker length * * The external merge driver should write the results in the * file named by %A, and signal that it has done with zero exit * status. */ fn->cmdline = xstrdup(value); return 0; } if (!strcmp("recursive", key)) { if (!value) return error("%s: lacks value", var); fn->recursive = xstrdup(value); return 0; } return 0; } static void initialize_ll_merge(void) { if (ll_user_merge_tail) return; ll_user_merge_tail = &ll_user_merge; git_config(read_merge_config, NULL); } static const struct ll_merge_driver *find_ll_merge_driver(const char *merge_attr) { struct ll_merge_driver *fn; const char *name; int i; initialize_ll_merge(); if (ATTR_TRUE(merge_attr)) return &ll_merge_drv[LL_TEXT_MERGE]; else if (ATTR_FALSE(merge_attr)) return &ll_merge_drv[LL_BINARY_MERGE]; else if (ATTR_UNSET(merge_attr)) { if (!default_ll_merge) return &ll_merge_drv[LL_TEXT_MERGE]; else name = default_ll_merge; } else name = merge_attr; for (fn = ll_user_merge; fn; fn = fn->next) if (!strcmp(fn->name, name)) return fn; for (i = 0; i < ARRAY_SIZE(ll_merge_drv); i++) if (!strcmp(ll_merge_drv[i].name, name)) return &ll_merge_drv[i]; /* default to the 3-way */ return &ll_merge_drv[LL_TEXT_MERGE]; } static int git_path_check_merge(const char *path, struct git_attr_check check[2]) { if (!check[0].attr) { check[0].attr = git_attr("merge"); check[1].attr = git_attr("conflict-marker-size"); } return git_check_attr(path, 2, check); } static void normalize_file(mmfile_t *mm, const char *path) { struct strbuf strbuf = STRBUF_INIT; if (renormalize_buffer(path, mm->ptr, mm->size, &strbuf)) { free(mm->ptr); mm->size = strbuf.len; mm->ptr = strbuf_detach(&strbuf, NULL); } } int ll_merge(mmbuffer_t *result_buf, const char *path, mmfile_t *ancestor, const char *ancestor_label, mmfile_t *ours, const char *our_label, mmfile_t *theirs, const char *their_label, const struct ll_merge_options *opts) { static struct git_attr_check check[2]; static const struct ll_merge_options default_opts; const char *ll_driver_name = NULL; int marker_size = DEFAULT_CONFLICT_MARKER_SIZE; const struct ll_merge_driver *driver; if (!opts) opts = &default_opts; if (opts->renormalize) { normalize_file(ancestor, path); normalize_file(ours, path); normalize_file(theirs, path); } if (!git_path_check_merge(path, check)) { ll_driver_name = check[0].value; if (check[1].value) { marker_size = atoi(check[1].value); if (marker_size <= 0) marker_size = DEFAULT_CONFLICT_MARKER_SIZE; } } driver = find_ll_merge_driver(ll_driver_name); if (opts->virtual_ancestor && driver->recursive) driver = find_ll_merge_driver(driver->recursive); return driver->fn(driver, result_buf, path, ancestor, ancestor_label, ours, our_label, theirs, their_label, opts, marker_size); } int ll_merge_marker_size(const char *path) { static struct git_attr_check check; int marker_size = DEFAULT_CONFLICT_MARKER_SIZE; if (!check.attr) check.attr = git_attr("conflict-marker-size"); if (!git_check_attr(path, 1, &check) && check.value) { marker_size = atoi(check.value); if (marker_size <= 0) marker_size = DEFAULT_CONFLICT_MARKER_SIZE; } return marker_size; }