2008-08-12 16:45:14 +00:00
|
|
|
/*
|
|
|
|
* Recursive Merge algorithm stolen from git-merge-recursive.py by
|
|
|
|
* Fredrik Kuivinen.
|
|
|
|
* The thieves were Alex Riesen and Johannes Schindelin, in June/July 2006
|
|
|
|
*/
|
2009-11-22 22:26:17 +00:00
|
|
|
#include "advice.h"
|
2008-08-12 16:45:14 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "cache-tree.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "blob.h"
|
|
|
|
#include "builtin.h"
|
|
|
|
#include "tree-walk.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "diffcore.h"
|
|
|
|
#include "tag.h"
|
|
|
|
#include "unpack-trees.h"
|
|
|
|
#include "string-list.h"
|
|
|
|
#include "xdiff-interface.h"
|
|
|
|
#include "ll-merge.h"
|
|
|
|
#include "attr.h"
|
|
|
|
#include "merge-recursive.h"
|
2008-09-29 18:04:20 +00:00
|
|
|
#include "dir.h"
|
2010-07-07 13:39:13 +00:00
|
|
|
#include "submodule.h"
|
2008-08-12 16:45:14 +00:00
|
|
|
|
2008-07-01 05:18:57 +00:00
|
|
|
static struct tree *shift_tree_object(struct tree *one, struct tree *two,
|
|
|
|
const char *subtree_shift)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
|
|
|
unsigned char shifted[20];
|
|
|
|
|
2008-07-01 05:18:57 +00:00
|
|
|
if (!*subtree_shift) {
|
|
|
|
shift_tree(one->object.sha1, two->object.sha1, shifted, 0);
|
|
|
|
} else {
|
|
|
|
shift_tree_by(one->object.sha1, two->object.sha1, shifted,
|
|
|
|
subtree_shift);
|
|
|
|
}
|
2008-08-12 16:45:14 +00:00
|
|
|
if (!hashcmp(two->object.sha1, shifted))
|
|
|
|
return two;
|
|
|
|
return lookup_tree(shifted);
|
|
|
|
}
|
|
|
|
|
2009-06-18 17:28:43 +00:00
|
|
|
static struct commit *make_virtual_commit(struct tree *tree, const char *comment)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
2014-06-10 21:39:11 +00:00
|
|
|
struct commit *commit = alloc_commit_node();
|
2011-11-07 21:26:22 +00:00
|
|
|
struct merge_remote_desc *desc = xmalloc(sizeof(*desc));
|
|
|
|
|
|
|
|
desc->name = comment;
|
|
|
|
desc->obj = (struct object *)commit;
|
2008-08-12 16:45:14 +00:00
|
|
|
commit->tree = tree;
|
2011-11-07 21:26:22 +00:00
|
|
|
commit->util = desc;
|
2008-08-12 16:45:14 +00:00
|
|
|
commit->object.parsed = 1;
|
|
|
|
return commit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 && hashcmp(a, b) == 0;
|
|
|
|
}
|
|
|
|
|
2010-09-20 08:28:53 +00:00
|
|
|
enum rename_type {
|
|
|
|
RENAME_NORMAL = 0,
|
|
|
|
RENAME_DELETE,
|
2011-08-12 05:20:08 +00:00
|
|
|
RENAME_ONE_FILE_TO_ONE,
|
2011-08-12 05:20:15 +00:00
|
|
|
RENAME_ONE_FILE_TO_TWO,
|
|
|
|
RENAME_TWO_FILES_TO_ONE
|
2010-09-20 08:28:53 +00:00
|
|
|
};
|
|
|
|
|
2011-08-12 05:20:08 +00:00
|
|
|
struct rename_conflict_info {
|
2010-09-20 08:28:53 +00:00
|
|
|
enum rename_type rename_type;
|
|
|
|
struct diff_filepair *pair1;
|
|
|
|
struct diff_filepair *pair2;
|
|
|
|
const char *branch1;
|
|
|
|
const char *branch2;
|
|
|
|
struct stage_data *dst_entry1;
|
|
|
|
struct stage_data *dst_entry2;
|
2011-08-12 05:20:16 +00:00
|
|
|
struct diff_filespec ren1_other;
|
|
|
|
struct diff_filespec ren2_other;
|
2010-09-20 08:28:53 +00:00
|
|
|
};
|
|
|
|
|
2008-08-12 16:45:14 +00:00
|
|
|
/*
|
|
|
|
* Since we want to write the index eventually, we cannot reuse the index
|
|
|
|
* for these (temporary) data.
|
|
|
|
*/
|
2011-03-16 07:08:34 +00:00
|
|
|
struct stage_data {
|
|
|
|
struct {
|
2008-08-12 16:45:14 +00:00
|
|
|
unsigned mode;
|
|
|
|
unsigned char sha[20];
|
|
|
|
} stages[4];
|
2011-08-12 05:20:08 +00:00
|
|
|
struct rename_conflict_info *rename_conflict_info;
|
2008-08-12 16:45:14 +00:00
|
|
|
unsigned processed:1;
|
|
|
|
};
|
|
|
|
|
2011-08-12 05:20:08 +00:00
|
|
|
static inline void setup_rename_conflict_info(enum rename_type rename_type,
|
|
|
|
struct diff_filepair *pair1,
|
|
|
|
struct diff_filepair *pair2,
|
|
|
|
const char *branch1,
|
|
|
|
const char *branch2,
|
|
|
|
struct stage_data *dst_entry1,
|
2011-08-12 05:20:16 +00:00
|
|
|
struct stage_data *dst_entry2,
|
|
|
|
struct merge_options *o,
|
|
|
|
struct stage_data *src_entry1,
|
|
|
|
struct stage_data *src_entry2)
|
2010-09-20 08:28:53 +00:00
|
|
|
{
|
2011-08-12 05:20:08 +00:00
|
|
|
struct rename_conflict_info *ci = xcalloc(1, sizeof(struct rename_conflict_info));
|
2010-09-20 08:28:53 +00:00
|
|
|
ci->rename_type = rename_type;
|
|
|
|
ci->pair1 = pair1;
|
|
|
|
ci->branch1 = branch1;
|
|
|
|
ci->branch2 = branch2;
|
|
|
|
|
|
|
|
ci->dst_entry1 = dst_entry1;
|
2011-08-12 05:20:08 +00:00
|
|
|
dst_entry1->rename_conflict_info = ci;
|
2010-09-20 08:28:53 +00:00
|
|
|
dst_entry1->processed = 0;
|
|
|
|
|
|
|
|
assert(!pair2 == !dst_entry2);
|
|
|
|
if (dst_entry2) {
|
|
|
|
ci->dst_entry2 = dst_entry2;
|
|
|
|
ci->pair2 = pair2;
|
2011-08-12 05:20:08 +00:00
|
|
|
dst_entry2->rename_conflict_info = ci;
|
2010-09-20 08:28:53 +00:00
|
|
|
}
|
2011-08-12 05:20:16 +00:00
|
|
|
|
|
|
|
if (rename_type == RENAME_TWO_FILES_TO_ONE) {
|
|
|
|
/*
|
|
|
|
* For each rename, there could have been
|
|
|
|
* modifications on the side of history where that
|
|
|
|
* file was not renamed.
|
|
|
|
*/
|
|
|
|
int ostage1 = o->branch1 == branch1 ? 3 : 2;
|
|
|
|
int ostage2 = ostage1 ^ 1;
|
|
|
|
|
|
|
|
ci->ren1_other.path = pair1->one->path;
|
|
|
|
hashcpy(ci->ren1_other.sha1, src_entry1->stages[ostage1].sha);
|
|
|
|
ci->ren1_other.mode = src_entry1->stages[ostage1].mode;
|
|
|
|
|
|
|
|
ci->ren2_other.path = pair2->one->path;
|
|
|
|
hashcpy(ci->ren2_other.sha1, src_entry2->stages[ostage2].sha);
|
|
|
|
ci->ren2_other.mode = src_entry2->stages[ostage2].mode;
|
2010-09-20 08:28:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-25 14:25:57 +00:00
|
|
|
static int show(struct merge_options *o, int v)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
2008-09-02 21:30:09 +00:00
|
|
|
return (!o->call_depth && o->verbosity >= v) || o->verbosity >= 5;
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
|
2008-09-03 00:30:03 +00:00
|
|
|
static void flush_output(struct merge_options *o)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
2008-09-03 00:30:03 +00:00
|
|
|
if (o->obuf.len) {
|
|
|
|
fputs(o->obuf.buf, stdout);
|
|
|
|
strbuf_reset(&o->obuf);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-14 21:33:13 +00:00
|
|
|
__attribute__((format (printf, 3, 4)))
|
2008-08-25 14:25:57 +00:00
|
|
|
static void output(struct merge_options *o, int v, const char *fmt, ...)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
2008-08-25 14:25:57 +00:00
|
|
|
if (!show(o, v))
|
2008-08-12 16:45:14 +00:00
|
|
|
return;
|
|
|
|
|
2008-09-03 00:30:03 +00:00
|
|
|
strbuf_grow(&o->obuf, o->call_depth * 2 + 2);
|
|
|
|
memset(o->obuf.buf + o->obuf.len, ' ', o->call_depth * 2);
|
|
|
|
strbuf_setlen(&o->obuf, o->obuf.len + o->call_depth * 2);
|
2008-08-12 16:45:14 +00:00
|
|
|
|
|
|
|
va_start(ap, fmt);
|
2011-02-26 05:08:53 +00:00
|
|
|
strbuf_vaddf(&o->obuf, fmt, ap);
|
2008-08-12 16:45:14 +00:00
|
|
|
va_end(ap);
|
|
|
|
|
2014-07-10 08:54:24 +00:00
|
|
|
strbuf_addch(&o->obuf, '\n');
|
2008-08-25 14:25:57 +00:00
|
|
|
if (!o->buffer_output)
|
2008-09-03 00:30:03 +00:00
|
|
|
flush_output(o);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
|
2008-09-02 21:30:09 +00:00
|
|
|
static void output_commit_title(struct merge_options *o, struct commit *commit)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
|
|
|
int i;
|
2008-09-03 00:30:03 +00:00
|
|
|
flush_output(o);
|
2008-09-02 21:30:09 +00:00
|
|
|
for (i = o->call_depth; i--;)
|
2008-08-12 16:45:14 +00:00
|
|
|
fputs(" ", stdout);
|
|
|
|
if (commit->util)
|
2011-11-07 21:26:22 +00:00
|
|
|
printf("virtual %s\n", merge_remote_util(commit)->name);
|
2008-08-12 16:45:14 +00:00
|
|
|
else {
|
|
|
|
printf("%s ", find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV));
|
|
|
|
if (parse_commit(commit) != 0)
|
2012-07-25 14:53:13 +00:00
|
|
|
printf(_("(bad commit)\n"));
|
2008-08-12 16:45:14 +00:00
|
|
|
else {
|
2010-07-22 13:18:34 +00:00
|
|
|
const char *title;
|
2014-06-10 21:44:13 +00:00
|
|
|
const char *msg = get_commit_buffer(commit, NULL);
|
2014-06-10 21:41:51 +00:00
|
|
|
int len = find_commit_subject(msg, &title);
|
2010-07-22 13:18:34 +00:00
|
|
|
if (len)
|
|
|
|
printf("%.*s\n", len, title);
|
2014-06-10 21:41:51 +00:00
|
|
|
unuse_commit_buffer(commit, msg);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int add_cacheinfo(unsigned int mode, const unsigned char *sha1,
|
|
|
|
const char *path, int stage, int refresh, int options)
|
|
|
|
{
|
|
|
|
struct cache_entry *ce;
|
2014-01-27 14:45:08 +00:00
|
|
|
ce = make_cache_entry(mode, sha1 ? sha1 : null_sha1, path, stage,
|
2014-01-27 14:45:09 +00:00
|
|
|
(refresh ? (CE_MATCH_REFRESH |
|
|
|
|
CE_MATCH_IGNORE_MISSING) : 0 ));
|
2008-08-12 16:45:14 +00:00
|
|
|
if (!ce)
|
2012-07-25 14:53:13 +00:00
|
|
|
return error(_("addinfo_cache failed for path '%s'"), path);
|
2008-08-12 16:45:14 +00:00
|
|
|
return add_cache_entry(ce, options);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void init_tree_desc_from_tree(struct tree_desc *desc, struct tree *tree)
|
|
|
|
{
|
|
|
|
parse_tree(tree);
|
|
|
|
init_tree_desc(desc, tree->buffer, tree->size);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int git_merge_trees(int index_only,
|
|
|
|
struct tree *common,
|
|
|
|
struct tree *head,
|
|
|
|
struct tree *merge)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
struct tree_desc t[3];
|
|
|
|
struct unpack_trees_options opts;
|
|
|
|
|
|
|
|
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;
|
|
|
|
opts.src_index = &the_index;
|
|
|
|
opts.dst_index = &the_index;
|
2010-09-02 11:57:34 +00:00
|
|
|
setup_unpack_trees_porcelain(&opts, "merge");
|
2008-08-12 16:45:14 +00:00
|
|
|
|
|
|
|
init_tree_desc_from_tree(t+0, common);
|
|
|
|
init_tree_desc_from_tree(t+1, head);
|
|
|
|
init_tree_desc_from_tree(t+2, merge);
|
|
|
|
|
|
|
|
rc = unpack_trees(3, t, &opts);
|
|
|
|
cache_tree_free(&active_cache_tree);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-08-25 14:25:57 +00:00
|
|
|
struct tree *write_tree_from_memory(struct merge_options *o)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
|
|
|
struct tree *result = NULL;
|
|
|
|
|
|
|
|
if (unmerged_cache()) {
|
|
|
|
int i;
|
2010-01-22 00:38:56 +00:00
|
|
|
fprintf(stderr, "BUG: There are unmerged index entries:\n");
|
2008-08-12 16:45:14 +00:00
|
|
|
for (i = 0; i < active_nr; i++) {
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 15:29:00 +00:00
|
|
|
const struct cache_entry *ce = active_cache[i];
|
2008-08-12 16:45:14 +00:00
|
|
|
if (ce_stage(ce))
|
2011-08-12 05:19:49 +00:00
|
|
|
fprintf(stderr, "BUG: %d %.*s\n", ce_stage(ce),
|
2010-01-22 00:38:56 +00:00
|
|
|
(int)ce_namelen(ce), ce->name);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
2010-01-22 00:38:56 +00:00
|
|
|
die("Bug in merge-recursive.c");
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!active_cache_tree)
|
|
|
|
active_cache_tree = cache_tree();
|
|
|
|
|
|
|
|
if (!cache_tree_fully_valid(active_cache_tree) &&
|
2014-06-13 12:19:32 +00:00
|
|
|
cache_tree_update(&the_index, 0) < 0)
|
2012-07-25 14:53:13 +00:00
|
|
|
die(_("error building trees"));
|
2008-08-12 16:45:14 +00:00
|
|
|
|
|
|
|
result = lookup_tree(active_cache_tree->sha1);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int save_files_dirs(const unsigned char *sha1,
|
|
|
|
const char *base, int baselen, const char *path,
|
|
|
|
unsigned int mode, int stage, void *context)
|
|
|
|
{
|
|
|
|
int len = strlen(path);
|
|
|
|
char *newpath = xmalloc(baselen + len + 1);
|
2008-09-03 17:08:56 +00:00
|
|
|
struct merge_options *o = context;
|
|
|
|
|
2008-08-12 16:45:14 +00:00
|
|
|
memcpy(newpath, base, baselen);
|
|
|
|
memcpy(newpath + baselen, path, len);
|
|
|
|
newpath[baselen + len] = '\0';
|
|
|
|
|
|
|
|
if (S_ISDIR(mode))
|
2010-06-25 23:41:35 +00:00
|
|
|
string_list_insert(&o->current_directory_set, newpath);
|
2008-08-12 16:45:14 +00:00
|
|
|
else
|
2010-06-25 23:41:35 +00:00
|
|
|
string_list_insert(&o->current_file_set, newpath);
|
2008-08-12 16:45:14 +00:00
|
|
|
free(newpath);
|
|
|
|
|
2009-01-25 00:52:05 +00:00
|
|
|
return (S_ISDIR(mode) ? READ_TREE_RECURSIVE : 0);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
|
2008-09-03 17:08:56 +00:00
|
|
|
static int get_files_dirs(struct merge_options *o, struct tree *tree)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
|
|
|
int n;
|
2011-03-25 09:34:19 +00:00
|
|
|
struct pathspec match_all;
|
2013-07-14 08:35:59 +00:00
|
|
|
memset(&match_all, 0, sizeof(match_all));
|
2011-03-25 09:34:19 +00:00
|
|
|
if (read_tree_recursive(tree, "", 0, 0, &match_all, save_files_dirs, o))
|
2008-08-12 16:45:14 +00:00
|
|
|
return 0;
|
2008-09-03 17:08:56 +00:00
|
|
|
n = o->current_file_set.nr + o->current_directory_set.nr;
|
2008-08-12 16:45:14 +00:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns an index_entry instance which doesn't have to correspond to
|
|
|
|
* a real cache entry in Git's index.
|
|
|
|
*/
|
|
|
|
static struct stage_data *insert_stage_data(const char *path,
|
|
|
|
struct tree *o, struct tree *a, struct tree *b,
|
|
|
|
struct string_list *entries)
|
|
|
|
{
|
|
|
|
struct string_list_item *item;
|
|
|
|
struct stage_data *e = xcalloc(1, sizeof(struct stage_data));
|
|
|
|
get_tree_entry(o->object.sha1, path,
|
|
|
|
e->stages[1].sha, &e->stages[1].mode);
|
|
|
|
get_tree_entry(a->object.sha1, path,
|
|
|
|
e->stages[2].sha, &e->stages[2].mode);
|
|
|
|
get_tree_entry(b->object.sha1, path,
|
|
|
|
e->stages[3].sha, &e->stages[3].mode);
|
2010-06-25 23:41:35 +00:00
|
|
|
item = string_list_insert(entries, path);
|
2008-08-12 16:45:14 +00:00
|
|
|
item->util = e;
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a dictionary mapping file names to stage_data objects. The
|
|
|
|
* dictionary contains one entry for every path with a non-zero stage entry.
|
|
|
|
*/
|
|
|
|
static struct string_list *get_unmerged(void)
|
|
|
|
{
|
|
|
|
struct string_list *unmerged = xcalloc(1, sizeof(struct string_list));
|
|
|
|
int i;
|
|
|
|
|
|
|
|
unmerged->strdup_strings = 1;
|
|
|
|
|
|
|
|
for (i = 0; i < active_nr; i++) {
|
|
|
|
struct string_list_item *item;
|
|
|
|
struct stage_data *e;
|
Convert "struct cache_entry *" to "const ..." wherever possible
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-09 15:29:00 +00:00
|
|
|
const struct cache_entry *ce = active_cache[i];
|
2008-08-12 16:45:14 +00:00
|
|
|
if (!ce_stage(ce))
|
|
|
|
continue;
|
|
|
|
|
2010-06-25 23:41:37 +00:00
|
|
|
item = string_list_lookup(unmerged, ce->name);
|
2008-08-12 16:45:14 +00:00
|
|
|
if (!item) {
|
2010-06-25 23:41:35 +00:00
|
|
|
item = string_list_insert(unmerged, ce->name);
|
2008-08-12 16:45:14 +00:00
|
|
|
item->util = xcalloc(1, sizeof(struct stage_data));
|
|
|
|
}
|
|
|
|
e = item->util;
|
|
|
|
e->stages[ce_stage(ce)].mode = ce->ce_mode;
|
|
|
|
hashcpy(e->stages[ce_stage(ce)].sha, ce->sha1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return unmerged;
|
|
|
|
}
|
|
|
|
|
2011-08-12 05:19:56 +00:00
|
|
|
static int string_list_df_name_compare(const void *a, const void *b)
|
2010-09-20 08:29:09 +00:00
|
|
|
{
|
2011-08-12 05:19:56 +00:00
|
|
|
const struct string_list_item *one = a;
|
|
|
|
const struct string_list_item *two = b;
|
|
|
|
int onelen = strlen(one->string);
|
|
|
|
int twolen = strlen(two->string);
|
|
|
|
/*
|
|
|
|
* Here we only care that entries for D/F conflicts are
|
|
|
|
* adjacent, in particular with the file of the D/F conflict
|
|
|
|
* appearing before files below the corresponding directory.
|
|
|
|
* The order of the rest of the list is irrelevant for us.
|
2010-09-20 08:29:09 +00:00
|
|
|
*
|
2011-08-12 05:19:56 +00:00
|
|
|
* To achieve this, we sort with df_name_compare and provide
|
|
|
|
* the mode S_IFDIR so that D/F conflicts will sort correctly.
|
|
|
|
* We use the mode S_IFDIR for everything else for simplicity,
|
|
|
|
* since in other cases any changes in their order due to
|
|
|
|
* sorting cause no problems for us.
|
|
|
|
*/
|
|
|
|
int cmp = df_name_compare(one->string, onelen, S_IFDIR,
|
|
|
|
two->string, twolen, S_IFDIR);
|
|
|
|
/*
|
|
|
|
* Now that 'foo' and 'foo/bar' compare equal, we have to make sure
|
|
|
|
* that 'foo' comes before 'foo/bar'.
|
2010-09-20 08:29:09 +00:00
|
|
|
*/
|
2011-08-12 05:19:56 +00:00
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
return onelen - twolen;
|
|
|
|
}
|
|
|
|
|
2011-08-12 05:19:58 +00:00
|
|
|
static void record_df_conflict_files(struct merge_options *o,
|
|
|
|
struct string_list *entries)
|
2010-09-20 08:29:09 +00:00
|
|
|
{
|
2011-08-12 05:19:58 +00:00
|
|
|
/* If there is a D/F conflict and the file for such a conflict
|
2011-09-20 20:25:57 +00:00
|
|
|
* currently exist in the working tree, we want to allow it to be
|
2011-08-12 05:20:07 +00:00
|
|
|
* removed to make room for the corresponding directory if needed.
|
|
|
|
* The files underneath the directories of such D/F conflicts will
|
|
|
|
* be processed before the corresponding file involved in the D/F
|
|
|
|
* conflict. If the D/F directory ends up being removed by the
|
|
|
|
* merge, then we won't have to touch the D/F file. If the D/F
|
|
|
|
* directory needs to be written to the working copy, then the D/F
|
|
|
|
* file will simply be removed (in make_room_for_path()) to make
|
|
|
|
* room for the necessary paths. Note that if both the directory
|
|
|
|
* and the file need to be present, then the D/F file will be
|
|
|
|
* reinstated with a new unique name at the time it is processed.
|
2010-09-20 08:29:09 +00:00
|
|
|
*/
|
2011-08-13 02:23:51 +00:00
|
|
|
struct string_list df_sorted_entries;
|
2010-09-20 08:29:09 +00:00
|
|
|
const char *last_file = NULL;
|
2010-10-21 14:34:33 +00:00
|
|
|
int last_len = 0;
|
2010-09-20 08:29:09 +00:00
|
|
|
int i;
|
|
|
|
|
2011-08-12 05:19:54 +00:00
|
|
|
/*
|
|
|
|
* If we're merging merge-bases, we don't want to bother with
|
|
|
|
* any working directory changes.
|
|
|
|
*/
|
|
|
|
if (o->call_depth)
|
|
|
|
return;
|
|
|
|
|
2011-08-12 05:19:56 +00:00
|
|
|
/* Ensure D/F conflicts are adjacent in the entries list. */
|
2011-08-13 02:23:51 +00:00
|
|
|
memset(&df_sorted_entries, 0, sizeof(struct string_list));
|
2010-09-20 08:29:09 +00:00
|
|
|
for (i = 0; i < entries->nr; i++) {
|
2011-08-13 02:23:51 +00:00
|
|
|
struct string_list_item *next = &entries->items[i];
|
|
|
|
string_list_append(&df_sorted_entries, next->string)->util =
|
|
|
|
next->util;
|
|
|
|
}
|
|
|
|
qsort(df_sorted_entries.items, entries->nr, sizeof(*entries->items),
|
2011-08-12 05:19:56 +00:00
|
|
|
string_list_df_name_compare);
|
|
|
|
|
2011-08-12 05:19:58 +00:00
|
|
|
string_list_clear(&o->df_conflict_file_set, 1);
|
2011-08-13 02:23:51 +00:00
|
|
|
for (i = 0; i < df_sorted_entries.nr; i++) {
|
|
|
|
const char *path = df_sorted_entries.items[i].string;
|
2010-09-20 08:29:09 +00:00
|
|
|
int len = strlen(path);
|
2011-08-13 02:23:51 +00:00
|
|
|
struct stage_data *e = df_sorted_entries.items[i].util;
|
2010-09-20 08:29:09 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if last_file & path correspond to a D/F conflict;
|
|
|
|
* i.e. whether path is last_file+'/'+<something>.
|
2011-08-12 05:19:58 +00:00
|
|
|
* If so, record that it's okay to remove last_file to make
|
|
|
|
* room for path and friends if needed.
|
2010-09-20 08:29:09 +00:00
|
|
|
*/
|
|
|
|
if (last_file &&
|
|
|
|
len > last_len &&
|
|
|
|
memcmp(path, last_file, last_len) == 0 &&
|
|
|
|
path[last_len] == '/') {
|
2011-08-12 05:19:58 +00:00
|
|
|
string_list_insert(&o->df_conflict_file_set, last_file);
|
2010-09-20 08:29:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine whether path could exist as a file in the
|
|
|
|
* working directory as a possible D/F conflict. This
|
|
|
|
* will only occur when it exists in stage 2 as a
|
|
|
|
* file.
|
|
|
|
*/
|
|
|
|
if (S_ISREG(e->stages[2].mode) || S_ISLNK(e->stages[2].mode)) {
|
|
|
|
last_file = path;
|
|
|
|
last_len = len;
|
|
|
|
} else {
|
|
|
|
last_file = NULL;
|
|
|
|
}
|
|
|
|
}
|
2011-08-13 02:23:51 +00:00
|
|
|
string_list_clear(&df_sorted_entries, 0);
|
2010-09-20 08:29:09 +00:00
|
|
|
}
|
|
|
|
|
2011-03-16 07:08:34 +00:00
|
|
|
struct rename {
|
2008-08-12 16:45:14 +00:00
|
|
|
struct diff_filepair *pair;
|
|
|
|
struct stage_data *src_entry;
|
|
|
|
struct stage_data *dst_entry;
|
|
|
|
unsigned processed:1;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get information of all renames which occurred between 'o_tree' and
|
|
|
|
* 'tree'. We need the three trees in the merge ('o_tree', 'a_tree' and
|
|
|
|
* 'b_tree') to be able to associate the correct cache entries with
|
|
|
|
* the rename information. 'tree' is always equal to either a_tree or b_tree.
|
|
|
|
*/
|
2008-08-25 14:25:57 +00:00
|
|
|
static struct string_list *get_renames(struct merge_options *o,
|
|
|
|
struct tree *tree,
|
|
|
|
struct tree *o_tree,
|
|
|
|
struct tree *a_tree,
|
|
|
|
struct tree *b_tree,
|
|
|
|
struct string_list *entries)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct string_list *renames;
|
|
|
|
struct diff_options opts;
|
|
|
|
|
|
|
|
renames = xcalloc(1, sizeof(struct string_list));
|
|
|
|
diff_setup(&opts);
|
|
|
|
DIFF_OPT_SET(&opts, RECURSIVE);
|
2012-03-22 22:52:24 +00:00
|
|
|
DIFF_OPT_CLR(&opts, RENAME_EMPTY);
|
2008-08-12 16:45:14 +00:00
|
|
|
opts.detect_rename = DIFF_DETECT_RENAME;
|
2008-08-25 14:25:57 +00:00
|
|
|
opts.rename_limit = o->merge_rename_limit >= 0 ? o->merge_rename_limit :
|
|
|
|
o->diff_rename_limit >= 0 ? o->diff_rename_limit :
|
2011-02-19 10:21:28 +00:00
|
|
|
1000;
|
2010-09-27 23:58:25 +00:00
|
|
|
opts.rename_score = o->rename_score;
|
2011-02-20 09:53:21 +00:00
|
|
|
opts.show_rename_progress = o->show_rename_progress;
|
2008-08-12 16:45:14 +00:00
|
|
|
opts.output_format = DIFF_FORMAT_NO_OUTPUT;
|
2012-08-03 12:16:24 +00:00
|
|
|
diff_setup_done(&opts);
|
2008-08-12 16:45:14 +00:00
|
|
|
diff_tree_sha1(o_tree->object.sha1, tree->object.sha1, "", &opts);
|
|
|
|
diffcore_std(&opts);
|
2011-02-19 10:20:51 +00:00
|
|
|
if (opts.needed_rename_limit > o->needed_rename_limit)
|
|
|
|
o->needed_rename_limit = opts.needed_rename_limit;
|
2008-08-12 16:45:14 +00:00
|
|
|
for (i = 0; i < diff_queued_diff.nr; ++i) {
|
|
|
|
struct string_list_item *item;
|
|
|
|
struct rename *re;
|
|
|
|
struct diff_filepair *pair = diff_queued_diff.queue[i];
|
|
|
|
if (pair->status != 'R') {
|
|
|
|
diff_free_filepair(pair);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
re = xmalloc(sizeof(*re));
|
|
|
|
re->processed = 0;
|
|
|
|
re->pair = pair;
|
2010-06-25 23:41:37 +00:00
|
|
|
item = string_list_lookup(entries, re->pair->one->path);
|
2008-08-12 16:45:14 +00:00
|
|
|
if (!item)
|
|
|
|
re->src_entry = insert_stage_data(re->pair->one->path,
|
|
|
|
o_tree, a_tree, b_tree, entries);
|
|
|
|
else
|
|
|
|
re->src_entry = item->util;
|
|
|
|
|
2010-06-25 23:41:37 +00:00
|
|
|
item = string_list_lookup(entries, re->pair->two->path);
|
2008-08-12 16:45:14 +00:00
|
|
|
if (!item)
|
|
|
|
re->dst_entry = insert_stage_data(re->pair->two->path,
|
|
|
|
o_tree, a_tree, b_tree, entries);
|
|
|
|
else
|
|
|
|
re->dst_entry = item->util;
|
2010-06-25 23:41:35 +00:00
|
|
|
item = string_list_insert(renames, pair->one->path);
|
2008-08-12 16:45:14 +00:00
|
|
|
item->util = re;
|
|
|
|
}
|
|
|
|
opts.output_format = DIFF_FORMAT_NO_OUTPUT;
|
|
|
|
diff_queued_diff.nr = 0;
|
|
|
|
diff_flush(&opts);
|
|
|
|
return renames;
|
|
|
|
}
|
|
|
|
|
2011-08-12 05:19:52 +00:00
|
|
|
static int update_stages(const char *path, const struct diff_filespec *o,
|
|
|
|
const struct diff_filespec *a,
|
|
|
|
const struct diff_filespec *b)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
2011-08-12 05:20:25 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* NOTE: It is usually a bad idea to call update_stages on a path
|
|
|
|
* before calling update_file on that same path, since it can
|
|
|
|
* sometimes lead to spurious "refusing to lose untracked file..."
|
|
|
|
* messages from update_file (via make_room_for path via
|
|
|
|
* would_lose_untracked). Instead, reverse the order of the calls
|
|
|
|
* (executing update_file first and then update_stages).
|
|
|
|
*/
|
2011-08-12 05:19:52 +00:00
|
|
|
int clear = 1;
|
|
|
|
int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK;
|
2008-08-12 16:45:14 +00:00
|
|
|
if (clear)
|
|
|
|
if (remove_file_from_cache(path))
|
|
|
|
return -1;
|
|
|
|
if (o)
|
|
|
|
if (add_cacheinfo(o->mode, o->sha1, path, 1, 0, options))
|
|
|
|
return -1;
|
|
|
|
if (a)
|
|
|
|
if (add_cacheinfo(a->mode, a->sha1, path, 2, 0, options))
|
|
|
|
return -1;
|
|
|
|
if (b)
|
|
|
|
if (add_cacheinfo(b->mode, b->sha1, path, 3, 0, options))
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-12 05:20:02 +00:00
|
|
|
static void update_entry(struct stage_data *entry,
|
|
|
|
struct diff_filespec *o,
|
|
|
|
struct diff_filespec *a,
|
|
|
|
struct diff_filespec *b)
|
2010-09-20 08:28:54 +00:00
|
|
|
{
|
|
|
|
entry->processed = 0;
|
|
|
|
entry->stages[1].mode = o->mode;
|
|
|
|
entry->stages[2].mode = a->mode;
|
|
|
|
entry->stages[3].mode = b->mode;
|
|
|
|
hashcpy(entry->stages[1].sha, o->sha1);
|
|
|
|
hashcpy(entry->stages[2].sha, a->sha1);
|
|
|
|
hashcpy(entry->stages[3].sha, b->sha1);
|
|
|
|
}
|
|
|
|
|
2008-09-02 21:53:47 +00:00
|
|
|
static int remove_file(struct merge_options *o, int clean,
|
|
|
|
const char *path, int no_wd)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
2008-09-02 21:53:47 +00:00
|
|
|
int update_cache = o->call_depth || clean;
|
|
|
|
int update_working_directory = !o->call_depth && !no_wd;
|
2008-08-12 16:45:14 +00:00
|
|
|
|
|
|
|
if (update_cache) {
|
|
|
|
if (remove_file_from_cache(path))
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (update_working_directory) {
|
2014-05-02 00:21:09 +00:00
|
|
|
if (ignore_case) {
|
|
|
|
struct cache_entry *ce;
|
|
|
|
ce = cache_file_exists(path, strlen(path), ignore_case);
|
|
|
|
if (ce && ce_stage(ce) == 0)
|
|
|
|
return 0;
|
|
|
|
}
|
2010-03-26 15:25:35 +00:00
|
|
|
if (remove_path(path))
|
2008-08-12 16:45:14 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-19 21:30:26 +00:00
|
|
|
/* add a string to a strbuf, but converting "/" to "_" */
|
|
|
|
static void add_flattened_path(struct strbuf *out, const char *s)
|
|
|
|
{
|
|
|
|
size_t i = out->len;
|
|
|
|
strbuf_addstr(out, s);
|
|
|
|
for (; i < out->len; i++)
|
|
|
|
if (out->buf[i] == '/')
|
|
|
|
out->buf[i] = '_';
|
|
|
|
}
|
|
|
|
|
2008-09-03 17:08:56 +00:00
|
|
|
static char *unique_path(struct merge_options *o, const char *path, const char *branch)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
2014-06-19 21:30:26 +00:00
|
|
|
struct strbuf newpath = STRBUF_INIT;
|
2008-08-12 16:45:14 +00:00
|
|
|
int suffix = 0;
|
|
|
|
struct stat st;
|
2014-06-19 21:30:26 +00:00
|
|
|
size_t base_len;
|
|
|
|
|
|
|
|
strbuf_addf(&newpath, "%s~", path);
|
|
|
|
add_flattened_path(&newpath, branch);
|
|
|
|
|
|
|
|
base_len = newpath.len;
|
|
|
|
while (string_list_has_string(&o->current_file_set, newpath.buf) ||
|
|
|
|
string_list_has_string(&o->current_directory_set, newpath.buf) ||
|
|
|
|
lstat(newpath.buf, &st) == 0) {
|
|
|
|
strbuf_setlen(&newpath, base_len);
|
|
|
|
strbuf_addf(&newpath, "_%d", suffix++);
|
|
|
|
}
|
|
|
|
|
|
|
|
string_list_insert(&o->current_file_set, newpath.buf);
|
|
|
|
return strbuf_detach(&newpath, NULL);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
|
2011-08-12 05:19:57 +00:00
|
|
|
static int dir_in_way(const char *path, int check_working_copy)
|
|
|
|
{
|
|
|
|
int pos, pathlen = strlen(path);
|
|
|
|
char *dirpath = xmalloc(pathlen + 2);
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
strcpy(dirpath, path);
|
|
|
|
dirpath[pathlen] = '/';
|
|
|
|
dirpath[pathlen+1] = '\0';
|
|
|
|
|
|
|
|
pos = cache_name_pos(dirpath, pathlen+1);
|
|
|
|
|
|
|
|
if (pos < 0)
|
|
|
|
pos = -1 - pos;
|
|
|
|
if (pos < active_nr &&
|
|
|
|
!strncmp(dirpath, active_cache[pos]->name, pathlen+1)) {
|
|
|
|
free(dirpath);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(dirpath);
|
|
|
|
return check_working_copy && !lstat(path, &st) && S_ISDIR(st.st_mode);
|
|
|
|
}
|
|
|
|
|
2011-08-12 05:19:59 +00:00
|
|
|
static int was_tracked(const char *path)
|
2008-12-15 10:41:24 +00:00
|
|
|
{
|
|
|
|
int pos = cache_name_pos(path, strlen(path));
|
|
|
|
|
|
|
|
if (pos < 0)
|
|
|
|
pos = -1 - pos;
|
|
|
|
while (pos < active_nr &&
|
|
|
|
!strcmp(path, active_cache[pos]->name)) {
|
|
|
|
/*
|
|
|
|
* If stage #0, it is definitely tracked.
|
|
|
|
* If it has stage #2 then it was tracked
|
|
|
|
* before this merge started. All other
|
|
|
|
* cases the path was not tracked.
|
|
|
|
*/
|
|
|
|
switch (ce_stage(active_cache[pos])) {
|
|
|
|
case 0:
|
|
|
|
case 2:
|
2011-08-12 05:19:59 +00:00
|
|
|
return 1;
|
2008-12-15 10:41:24 +00:00
|
|
|
}
|
|
|
|
pos++;
|
|
|
|
}
|
2011-08-12 05:19:59 +00:00
|
|
|
return 0;
|
2008-12-15 10:41:24 +00:00
|
|
|
}
|
|
|
|
|
2011-08-12 05:19:59 +00:00
|
|
|
static int would_lose_untracked(const char *path)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
2011-08-12 05:19:59 +00:00
|
|
|
return !was_tracked(path) && file_exists(path);
|
2008-12-15 10:41:24 +00:00
|
|
|
}
|
|
|
|
|
2011-08-12 05:20:01 +00:00
|
|
|
static int make_room_for_path(struct merge_options *o, const char *path)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
2011-08-12 05:20:01 +00:00
|
|
|
int status, i;
|
2012-07-25 14:53:13 +00:00
|
|
|
const char *msg = _("failed to create path '%s'%s");
|
2008-08-12 16:45:14 +00:00
|
|
|
|
2011-08-12 05:20:01 +00:00
|
|
|
/* Unlink any D/F conflict files that are in the way */
|
|
|
|
for (i = 0; i < o->df_conflict_file_set.nr; i++) {
|
|
|
|
const char *df_path = o->df_conflict_file_set.items[i].string;
|
|
|
|
size_t pathlen = strlen(path);
|
|
|
|
size_t df_pathlen = strlen(df_path);
|
|
|
|
if (df_pathlen < pathlen &&
|
|
|
|
path[df_pathlen] == '/' &&
|
|
|
|
strncmp(path, df_path, df_pathlen) == 0) {
|
|
|
|
output(o, 3,
|
2012-07-25 14:53:13 +00:00
|
|
|
_("Removing %s to make room for subdirectory\n"),
|
2011-08-12 05:20:01 +00:00
|
|
|
df_path);
|
|
|
|
unlink(df_path);
|
|
|
|
unsorted_string_list_delete_item(&o->df_conflict_file_set,
|
|
|
|
i, 0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure leading directories are created */
|
2008-08-12 16:45:14 +00:00
|
|
|
status = safe_create_leading_directories_const(path);
|
|
|
|
if (status) {
|
2014-01-06 13:45:25 +00:00
|
|
|
if (status == SCLD_EXISTS) {
|
2008-08-12 16:45:14 +00:00
|
|
|
/* something else exists */
|
2012-07-25 14:53:13 +00:00
|
|
|
error(msg, path, _(": perhaps a D/F conflict?"));
|
2008-08-12 16:45:14 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
die(msg, path, "");
|
|
|
|
}
|
|
|
|
|
2008-12-15 10:41:24 +00:00
|
|
|
/*
|
|
|
|
* Do not unlink a file in the work tree if we are not
|
|
|
|
* tracking it.
|
|
|
|
*/
|
|
|
|
if (would_lose_untracked(path))
|
2012-07-25 14:53:13 +00:00
|
|
|
return error(_("refusing to lose untracked file at '%s'"),
|
2008-12-15 10:41:24 +00:00
|
|
|
path);
|
|
|
|
|
2008-08-12 16:45:14 +00:00
|
|
|
/* Successful unlink is good.. */
|
|
|
|
if (!unlink(path))
|
|
|
|
return 0;
|
|
|
|
/* .. and so is no existing file */
|
|
|
|
if (errno == ENOENT)
|
|
|
|
return 0;
|
|
|
|
/* .. but not some other error (who really cares what?) */
|
2012-07-25 14:53:13 +00:00
|
|
|
return error(msg, path, _(": perhaps a D/F conflict?"));
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
|
2008-09-02 21:53:47 +00:00
|
|
|
static void update_file_flags(struct merge_options *o,
|
|
|
|
const unsigned char *sha,
|
2008-08-12 16:45:14 +00:00
|
|
|
unsigned mode,
|
|
|
|
const char *path,
|
|
|
|
int update_cache,
|
|
|
|
int update_wd)
|
|
|
|
{
|
2008-09-02 21:53:47 +00:00
|
|
|
if (o->call_depth)
|
2008-08-12 16:45:14 +00:00
|
|
|
update_wd = 0;
|
|
|
|
|
|
|
|
if (update_wd) {
|
|
|
|
enum object_type type;
|
|
|
|
void *buf;
|
|
|
|
unsigned long size;
|
|
|
|
|
2010-07-07 13:39:13 +00:00
|
|
|
if (S_ISGITLINK(mode)) {
|
2009-04-29 18:08:18 +00:00
|
|
|
/*
|
|
|
|
* We may later decide to recursively descend into
|
|
|
|
* the submodule directory and update its index
|
|
|
|
* and/or work tree, but we do not do that now.
|
|
|
|
*/
|
2010-07-07 13:39:13 +00:00
|
|
|
update_wd = 0;
|
2009-04-29 18:08:18 +00:00
|
|
|
goto update_index;
|
2010-07-07 13:39:13 +00:00
|
|
|
}
|
2008-08-12 16:45:14 +00:00
|
|
|
|
|
|
|
buf = read_sha1_file(sha, &type, &size);
|
|
|
|
if (!buf)
|
2012-07-25 14:53:13 +00:00
|
|
|
die(_("cannot read object %s '%s'"), sha1_to_hex(sha), path);
|
2008-08-12 16:45:14 +00:00
|
|
|
if (type != OBJ_BLOB)
|
2012-07-25 14:53:13 +00:00
|
|
|
die(_("blob expected for %s '%s'"), sha1_to_hex(sha), path);
|
2008-08-12 16:45:14 +00:00
|
|
|
if (S_ISREG(mode)) {
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf strbuf = STRBUF_INIT;
|
2008-08-12 16:45:14 +00:00
|
|
|
if (convert_to_working_tree(path, buf, size, &strbuf)) {
|
|
|
|
free(buf);
|
|
|
|
size = strbuf.len;
|
|
|
|
buf = strbuf_detach(&strbuf, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-08-12 05:20:01 +00:00
|
|
|
if (make_room_for_path(o, path) < 0) {
|
2008-08-12 16:45:14 +00:00
|
|
|
update_wd = 0;
|
|
|
|
free(buf);
|
|
|
|
goto update_index;
|
|
|
|
}
|
|
|
|
if (S_ISREG(mode) || (!has_symlinks && S_ISLNK(mode))) {
|
|
|
|
int fd;
|
|
|
|
if (mode & 0100)
|
|
|
|
mode = 0777;
|
|
|
|
else
|
|
|
|
mode = 0666;
|
|
|
|
fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);
|
|
|
|
if (fd < 0)
|
2012-07-25 14:53:13 +00:00
|
|
|
die_errno(_("failed to open '%s'"), path);
|
2012-08-03 12:16:25 +00:00
|
|
|
write_in_full(fd, buf, size);
|
2008-08-12 16:45:14 +00:00
|
|
|
close(fd);
|
|
|
|
} else if (S_ISLNK(mode)) {
|
|
|
|
char *lnk = xmemdupz(buf, size);
|
|
|
|
safe_create_leading_directories_const(path);
|
|
|
|
unlink(path);
|
2008-12-05 00:39:14 +00:00
|
|
|
if (symlink(lnk, path))
|
2012-07-25 14:53:13 +00:00
|
|
|
die_errno(_("failed to symlink '%s'"), path);
|
2008-08-12 16:45:14 +00:00
|
|
|
free(lnk);
|
|
|
|
} else
|
2012-07-25 14:53:13 +00:00
|
|
|
die(_("do not know what to do with %06o %s '%s'"),
|
2008-08-12 16:45:14 +00:00
|
|
|
mode, sha1_to_hex(sha), path);
|
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
update_index:
|
|
|
|
if (update_cache)
|
|
|
|
add_cacheinfo(mode, sha, path, 0, update_wd, ADD_CACHE_OK_TO_ADD);
|
|
|
|
}
|
|
|
|
|
2008-09-02 21:53:47 +00:00
|
|
|
static void update_file(struct merge_options *o,
|
|
|
|
int clean,
|
2008-08-12 16:45:14 +00:00
|
|
|
const unsigned char *sha,
|
|
|
|
unsigned mode,
|
|
|
|
const char *path)
|
|
|
|
{
|
2008-09-02 21:53:47 +00:00
|
|
|
update_file_flags(o, sha, mode, path, o->call_depth || clean, !o->call_depth);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Low level file merging, update and removal */
|
|
|
|
|
2011-03-16 07:08:34 +00:00
|
|
|
struct merge_file_info {
|
2008-08-12 16:45:14 +00:00
|
|
|
unsigned char sha[20];
|
|
|
|
unsigned mode;
|
|
|
|
unsigned clean:1,
|
|
|
|
merge:1;
|
|
|
|
};
|
|
|
|
|
2008-09-02 21:53:47 +00:00
|
|
|
static int merge_3way(struct merge_options *o,
|
|
|
|
mmbuffer_t *result_buf,
|
2011-08-12 05:19:51 +00:00
|
|
|
const struct diff_filespec *one,
|
|
|
|
const struct diff_filespec *a,
|
|
|
|
const struct diff_filespec *b,
|
2008-08-12 16:45:14 +00:00
|
|
|
const char *branch1,
|
|
|
|
const char *branch2)
|
|
|
|
{
|
|
|
|
mmfile_t orig, src1, src2;
|
2010-08-26 05:49:53 +00:00
|
|
|
struct ll_merge_options ll_opts = {0};
|
2010-03-21 00:41:38 +00:00
|
|
|
char *base_name, *name1, *name2;
|
2008-08-12 16:45:14 +00:00
|
|
|
int merge_status;
|
2009-11-26 02:23:55 +00:00
|
|
|
|
2010-08-26 05:49:53 +00:00
|
|
|
ll_opts.renormalize = o->renormalize;
|
2010-08-26 05:50:45 +00:00
|
|
|
ll_opts.xdl_opts = o->xdl_opts;
|
2010-08-26 05:49:53 +00:00
|
|
|
|
|
|
|
if (o->call_depth) {
|
|
|
|
ll_opts.virtual_ancestor = 1;
|
|
|
|
ll_opts.variant = 0;
|
|
|
|
} else {
|
2009-11-26 02:23:55 +00:00
|
|
|
switch (o->recursive_variant) {
|
|
|
|
case MERGE_RECURSIVE_OURS:
|
2010-08-26 05:49:53 +00:00
|
|
|
ll_opts.variant = XDL_MERGE_FAVOR_OURS;
|
2009-11-26 02:23:55 +00:00
|
|
|
break;
|
|
|
|
case MERGE_RECURSIVE_THEIRS:
|
2010-08-26 05:49:53 +00:00
|
|
|
ll_opts.variant = XDL_MERGE_FAVOR_THEIRS;
|
2009-11-26 02:23:55 +00:00
|
|
|
break;
|
|
|
|
default:
|
2010-08-26 05:49:53 +00:00
|
|
|
ll_opts.variant = 0;
|
2009-11-26 02:23:55 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-08-12 16:45:14 +00:00
|
|
|
|
2010-03-21 00:41:38 +00:00
|
|
|
if (strcmp(a->path, b->path) ||
|
|
|
|
(o->ancestor != NULL && strcmp(a->path, one->path) != 0)) {
|
|
|
|
base_name = o->ancestor == NULL ? NULL :
|
2012-09-04 17:31:14 +00:00
|
|
|
mkpathdup("%s:%s", o->ancestor, one->path);
|
|
|
|
name1 = mkpathdup("%s:%s", branch1, a->path);
|
|
|
|
name2 = mkpathdup("%s:%s", branch2, b->path);
|
2009-07-01 20:18:04 +00:00
|
|
|
} else {
|
2010-03-21 00:41:38 +00:00
|
|
|
base_name = o->ancestor == NULL ? NULL :
|
2012-09-04 17:31:14 +00:00
|
|
|
mkpathdup("%s", o->ancestor);
|
|
|
|
name1 = mkpathdup("%s", branch1);
|
|
|
|
name2 = mkpathdup("%s", branch2);
|
2009-07-01 20:18:04 +00:00
|
|
|
}
|
2008-08-12 16:45:14 +00:00
|
|
|
|
2010-02-16 23:42:55 +00:00
|
|
|
read_mmblob(&orig, one->sha1);
|
|
|
|
read_mmblob(&src1, a->sha1);
|
|
|
|
read_mmblob(&src2, b->sha1);
|
2008-08-12 16:45:14 +00:00
|
|
|
|
2010-03-21 00:41:38 +00:00
|
|
|
merge_status = ll_merge(result_buf, a->path, &orig, base_name,
|
2010-08-26 05:49:53 +00:00
|
|
|
&src1, name1, &src2, name2, &ll_opts);
|
2008-08-12 16:45:14 +00:00
|
|
|
|
2012-09-04 17:31:14 +00:00
|
|
|
free(base_name);
|
2008-08-12 16:45:14 +00:00
|
|
|
free(name1);
|
|
|
|
free(name2);
|
|
|
|
free(orig.ptr);
|
|
|
|
free(src1.ptr);
|
|
|
|
free(src2.ptr);
|
|
|
|
return merge_status;
|
|
|
|
}
|
|
|
|
|
2011-08-12 05:20:12 +00:00
|
|
|
static struct merge_file_info merge_file_1(struct merge_options *o,
|
|
|
|
const struct diff_filespec *one,
|
|
|
|
const struct diff_filespec *a,
|
|
|
|
const struct diff_filespec *b,
|
|
|
|
const char *branch1,
|
|
|
|
const char *branch2)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
|
|
|
struct merge_file_info result;
|
|
|
|
result.merge = 0;
|
|
|
|
result.clean = 1;
|
|
|
|
|
|
|
|
if ((S_IFMT & a->mode) != (S_IFMT & b->mode)) {
|
|
|
|
result.clean = 0;
|
|
|
|
if (S_ISREG(a->mode)) {
|
|
|
|
result.mode = a->mode;
|
|
|
|
hashcpy(result.sha, a->sha1);
|
|
|
|
} else {
|
|
|
|
result.mode = b->mode;
|
|
|
|
hashcpy(result.sha, b->sha1);
|
|
|
|
}
|
|
|
|
} else {
|
2008-09-02 21:53:47 +00:00
|
|
|
if (!sha_eq(a->sha1, one->sha1) && !sha_eq(b->sha1, one->sha1))
|
2008-08-12 16:45:14 +00:00
|
|
|
result.merge = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Merge modes
|
|
|
|
*/
|
2008-09-02 21:53:47 +00:00
|
|
|
if (a->mode == b->mode || a->mode == one->mode)
|
2008-08-12 16:45:14 +00:00
|
|
|
result.mode = b->mode;
|
|
|
|
else {
|
|
|
|
result.mode = a->mode;
|
2008-09-02 21:53:47 +00:00
|
|
|
if (b->mode != one->mode) {
|
2008-08-12 16:45:14 +00:00
|
|
|
result.clean = 0;
|
|
|
|
result.merge = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-09-02 21:53:47 +00:00
|
|
|
if (sha_eq(a->sha1, b->sha1) || sha_eq(a->sha1, one->sha1))
|
2008-08-12 16:45:14 +00:00
|
|
|
hashcpy(result.sha, b->sha1);
|
2008-09-02 21:53:47 +00:00
|
|
|
else if (sha_eq(b->sha1, one->sha1))
|
2008-08-12 16:45:14 +00:00
|
|
|
hashcpy(result.sha, a->sha1);
|
|
|
|
else if (S_ISREG(a->mode)) {
|
|
|
|
mmbuffer_t result_buf;
|
|
|
|
int merge_status;
|
|
|
|
|
2008-09-02 21:53:47 +00:00
|
|
|
merge_status = merge_3way(o, &result_buf, one, a, b,
|
2008-08-12 16:45:14 +00:00
|
|
|
branch1, branch2);
|
|
|
|
|
|
|
|
if ((merge_status < 0) || !result_buf.ptr)
|
2012-07-25 14:53:13 +00:00
|
|
|
die(_("Failed to execute internal merge"));
|
2008-08-12 16:45:14 +00:00
|
|
|
|
|
|
|
if (write_sha1_file(result_buf.ptr, result_buf.size,
|
|
|
|
blob_type, result.sha))
|
2012-07-25 14:53:13 +00:00
|
|
|
die(_("Unable to add %s to database"),
|
2008-08-12 16:45:14 +00:00
|
|
|
a->path);
|
|
|
|
|
|
|
|
free(result_buf.ptr);
|
|
|
|
result.clean = (merge_status == 0);
|
|
|
|
} else if (S_ISGITLINK(a->mode)) {
|
2011-10-13 12:59:05 +00:00
|
|
|
result.clean = merge_submodule(result.sha,
|
|
|
|
one->path, one->sha1,
|
|
|
|
a->sha1, b->sha1,
|
|
|
|
!o->call_depth);
|
2008-08-12 16:45:14 +00:00
|
|
|
} else if (S_ISLNK(a->mode)) {
|
|
|
|
hashcpy(result.sha, a->sha1);
|
|
|
|
|
|
|
|
if (!sha_eq(a->sha1, b->sha1))
|
|
|
|
result.clean = 0;
|
|
|
|
} else {
|
2012-07-25 14:53:13 +00:00
|
|
|
die(_("unsupported object type in the tree"));
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2011-08-12 05:20:17 +00:00
|
|
|
static struct merge_file_info
|
|
|
|
merge_file_special_markers(struct merge_options *o,
|
|
|
|
const struct diff_filespec *one,
|
|
|
|
const struct diff_filespec *a,
|
|
|
|
const struct diff_filespec *b,
|
|
|
|
const char *branch1,
|
|
|
|
const char *filename1,
|
|
|
|
const char *branch2,
|
|
|
|
const char *filename2)
|
|
|
|
{
|
|
|
|
char *side1 = NULL;
|
|
|
|
char *side2 = NULL;
|
|
|
|
struct merge_file_info mfi;
|
|
|
|
|
2014-06-19 21:24:33 +00:00
|
|
|
if (filename1)
|
|
|
|
side1 = xstrfmt("%s:%s", branch1, filename1);
|
|
|
|
if (filename2)
|
|
|
|
side2 = xstrfmt("%s:%s", branch2, filename2);
|
2011-08-12 05:20:17 +00:00
|
|
|
|
|
|
|
mfi = merge_file_1(o, one, a, b,
|
|
|
|
side1 ? side1 : branch1, side2 ? side2 : branch2);
|
|
|
|
free(side1);
|
|
|
|
free(side2);
|
|
|
|
return mfi;
|
|
|
|
}
|
|
|
|
|
2012-12-06 23:08:01 +00:00
|
|
|
static struct merge_file_info merge_file_one(struct merge_options *o,
|
2011-08-12 05:20:12 +00:00
|
|
|
const char *path,
|
|
|
|
const unsigned char *o_sha, int o_mode,
|
|
|
|
const unsigned char *a_sha, int a_mode,
|
|
|
|
const unsigned char *b_sha, int b_mode,
|
|
|
|
const char *branch1,
|
|
|
|
const char *branch2)
|
|
|
|
{
|
|
|
|
struct diff_filespec one, a, b;
|
|
|
|
|
|
|
|
one.path = a.path = b.path = (char *)path;
|
|
|
|
hashcpy(one.sha1, o_sha);
|
|
|
|
one.mode = o_mode;
|
|
|
|
hashcpy(a.sha1, a_sha);
|
|
|
|
a.mode = a_mode;
|
|
|
|
hashcpy(b.sha1, b_sha);
|
|
|
|
b.mode = b_mode;
|
|
|
|
return merge_file_1(o, &one, &a, &b, branch1, branch2);
|
|
|
|
}
|
|
|
|
|
2011-08-12 05:20:19 +00:00
|
|
|
static void handle_change_delete(struct merge_options *o,
|
|
|
|
const char *path,
|
|
|
|
const unsigned char *o_sha, int o_mode,
|
|
|
|
const unsigned char *a_sha, int a_mode,
|
|
|
|
const unsigned char *b_sha, int b_mode,
|
|
|
|
const char *change, const char *change_past)
|
|
|
|
{
|
|
|
|
char *renamed = NULL;
|
|
|
|
if (dir_in_way(path, !o->call_depth)) {
|
|
|
|
renamed = unique_path(o, path, a_sha ? o->branch1 : o->branch2);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (o->call_depth) {
|
|
|
|
/*
|
|
|
|
* We cannot arbitrarily accept either a_sha or b_sha as
|
|
|
|
* correct; since there is no true "middle point" between
|
|
|
|
* them, simply reuse the base version for virtual merge base.
|
|
|
|
*/
|
|
|
|
remove_file_from_cache(path);
|
|
|
|
update_file(o, 0, o_sha, o_mode, renamed ? renamed : path);
|
|
|
|
} else if (!a_sha) {
|
2012-07-25 14:53:13 +00:00
|
|
|
if (!renamed) {
|
|
|
|
output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "
|
|
|
|
"and %s in %s. Version %s of %s left in tree."),
|
|
|
|
change, path, o->branch1, change_past,
|
|
|
|
o->branch2, o->branch2, path);
|
|
|
|
update_file(o, 0, b_sha, b_mode, path);
|
|
|
|
} else {
|
|
|
|
output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "
|
|
|
|
"and %s in %s. Version %s of %s left in tree at %s."),
|
|
|
|
change, path, o->branch1, change_past,
|
|
|
|
o->branch2, o->branch2, path, renamed);
|
|
|
|
update_file(o, 0, b_sha, b_mode, renamed);
|
|
|
|
}
|
2011-08-12 05:20:19 +00:00
|
|
|
} else {
|
2012-07-25 14:53:13 +00:00
|
|
|
if (!renamed) {
|
|
|
|
output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "
|
|
|
|
"and %s in %s. Version %s of %s left in tree."),
|
|
|
|
change, path, o->branch2, change_past,
|
|
|
|
o->branch1, o->branch1, path);
|
|
|
|
} else {
|
|
|
|
output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "
|
|
|
|
"and %s in %s. Version %s of %s left in tree at %s."),
|
|
|
|
change, path, o->branch2, change_past,
|
|
|
|
o->branch1, o->branch1, path, renamed);
|
2011-08-12 05:20:27 +00:00
|
|
|
update_file(o, 0, a_sha, a_mode, renamed);
|
2012-07-25 14:53:13 +00:00
|
|
|
}
|
2011-08-12 05:20:27 +00:00
|
|
|
/*
|
|
|
|
* No need to call update_file() on path when !renamed, since
|
|
|
|
* that would needlessly touch path. We could call
|
|
|
|
* update_file_flags() with update_cache=0 and update_wd=0,
|
|
|
|
* but that's a no-op.
|
|
|
|
*/
|
2011-08-12 05:20:19 +00:00
|
|
|
}
|
|
|
|
free(renamed);
|
|
|
|
}
|
|
|
|
|
2010-09-20 08:28:50 +00:00
|
|
|
static void conflict_rename_delete(struct merge_options *o,
|
|
|
|
struct diff_filepair *pair,
|
|
|
|
const char *rename_branch,
|
|
|
|
const char *other_branch)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
2011-08-12 05:20:20 +00:00
|
|
|
const struct diff_filespec *orig = pair->one;
|
|
|
|
const struct diff_filespec *dest = pair->two;
|
|
|
|
const unsigned char *a_sha = NULL;
|
|
|
|
const unsigned char *b_sha = NULL;
|
|
|
|
int a_mode = 0;
|
|
|
|
int b_mode = 0;
|
|
|
|
|
|
|
|
if (rename_branch == o->branch1) {
|
|
|
|
a_sha = dest->sha1;
|
|
|
|
a_mode = dest->mode;
|
|
|
|
} else {
|
|
|
|
b_sha = dest->sha1;
|
|
|
|
b_mode = dest->mode;
|
|
|
|
}
|
2010-09-20 08:28:50 +00:00
|
|
|
|
2011-08-12 05:20:25 +00:00
|
|
|
handle_change_delete(o,
|
|
|
|
o->call_depth ? orig->path : dest->path,
|
|
|
|
orig->sha1, orig->mode,
|
|
|
|
a_sha, a_mode,
|
|
|
|
b_sha, b_mode,
|
2012-07-25 14:53:13 +00:00
|
|
|
_("rename"), _("renamed"));
|
2011-08-12 05:20:25 +00:00
|
|
|
|
2011-08-12 05:20:20 +00:00
|
|
|
if (o->call_depth) {
|
|
|
|
remove_file_from_cache(dest->path);
|
|
|
|
} else {
|
|
|
|
update_stages(dest->path, NULL,
|
|
|
|
rename_branch == o->branch1 ? dest : NULL,
|
|
|
|
rename_branch == o->branch1 ? NULL : dest);
|
2010-09-20 08:29:05 +00:00
|
|
|
}
|
2011-08-12 05:20:20 +00:00
|
|
|
|
2010-09-20 08:28:50 +00:00
|
|
|
}
|
|
|
|
|
2011-08-12 05:20:21 +00:00
|
|
|
static struct diff_filespec *filespec_from_entry(struct diff_filespec *target,
|
|
|
|
struct stage_data *entry,
|
|
|
|
int stage)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
2011-08-12 05:20:21 +00:00
|
|
|
unsigned char *sha = entry->stages[stage].sha;
|
|
|
|
unsigned mode = entry->stages[stage].mode;
|
|
|
|
if (mode == 0 || is_null_sha1(sha))
|
|
|
|
return NULL;
|
|
|
|
hashcpy(target->sha1, sha);
|
|
|
|
target->mode = mode;
|
|
|
|
return target;
|
|
|
|
}
|
|
|
|
|
2011-08-12 05:20:22 +00:00
|
|
|
static void handle_file(struct merge_options *o,
|
|
|
|
struct diff_filespec *rename,
|
|
|
|
int stage,
|
|
|
|
struct rename_conflict_info *ci)
|
|
|
|
{
|
|
|
|
char *dst_name = rename->path;
|
|
|
|
struct stage_data *dst_entry;
|
|
|
|
const char *cur_branch, *other_branch;
|
|
|
|
struct diff_filespec other;
|
|
|
|
struct diff_filespec *add;
|
|
|
|
|
|
|
|
if (stage == 2) {
|
|
|
|
dst_entry = ci->dst_entry1;
|
|
|
|
cur_branch = ci->branch1;
|
|
|
|
other_branch = ci->branch2;
|
|
|
|
} else {
|
|
|
|
dst_entry = ci->dst_entry2;
|
|
|
|
cur_branch = ci->branch2;
|
|
|
|
other_branch = ci->branch1;
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
2011-08-12 05:20:22 +00:00
|
|
|
|
|
|
|
add = filespec_from_entry(&other, dst_entry, stage ^ 1);
|
|
|
|
if (add) {
|
|
|
|
char *add_name = unique_path(o, rename->path, other_branch);
|
|
|
|
update_file(o, 0, add->sha1, add->mode, add_name);
|
|
|
|
|
|
|
|
remove_file(o, 0, rename->path, 0);
|
|
|
|
dst_name = unique_path(o, rename->path, cur_branch);
|
|
|
|
} else {
|
|
|
|
if (dir_in_way(rename->path, !o->call_depth)) {
|
|
|
|
dst_name = unique_path(o, rename->path, cur_branch);
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 1, _("%s is a directory in %s adding as %s instead"),
|
2011-08-12 05:20:22 +00:00
|
|
|
rename->path, other_branch, dst_name);
|
|
|
|
}
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
2011-08-12 05:20:22 +00:00
|
|
|
update_file(o, 0, rename->sha1, rename->mode, dst_name);
|
2011-08-12 05:20:25 +00:00
|
|
|
if (stage == 2)
|
|
|
|
update_stages(rename->path, NULL, rename, add);
|
|
|
|
else
|
|
|
|
update_stages(rename->path, NULL, add, rename);
|
2011-08-12 05:20:22 +00:00
|
|
|
|
|
|
|
if (dst_name != rename->path)
|
|
|
|
free(dst_name);
|
|
|
|
}
|
|
|
|
|
2010-09-20 08:28:48 +00:00
|
|
|
static void conflict_rename_rename_1to2(struct merge_options *o,
|
2011-08-12 05:20:14 +00:00
|
|
|
struct rename_conflict_info *ci)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
2010-09-20 08:28:48 +00:00
|
|
|
/* One file was renamed in both branches, but to different names. */
|
2011-08-12 05:20:14 +00:00
|
|
|
struct diff_filespec *one = ci->pair1->one;
|
|
|
|
struct diff_filespec *a = ci->pair1->two;
|
|
|
|
struct diff_filespec *b = ci->pair2->two;
|
2011-08-12 05:20:08 +00:00
|
|
|
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 1, _("CONFLICT (rename/rename): "
|
2011-08-12 05:20:08 +00:00
|
|
|
"Rename \"%s\"->\"%s\" in branch \"%s\" "
|
2012-07-25 14:53:13 +00:00
|
|
|
"rename \"%s\"->\"%s\" in \"%s\"%s"),
|
2011-08-12 05:20:14 +00:00
|
|
|
one->path, a->path, ci->branch1,
|
|
|
|
one->path, b->path, ci->branch2,
|
2012-07-25 14:53:13 +00:00
|
|
|
o->call_depth ? _(" (left unresolved)") : "");
|
2008-09-02 21:53:47 +00:00
|
|
|
if (o->call_depth) {
|
2011-08-12 05:20:13 +00:00
|
|
|
struct merge_file_info mfi;
|
2011-08-12 05:20:29 +00:00
|
|
|
struct diff_filespec other;
|
|
|
|
struct diff_filespec *add;
|
2012-12-06 23:08:01 +00:00
|
|
|
mfi = merge_file_one(o, one->path,
|
2011-08-12 05:20:14 +00:00
|
|
|
one->sha1, one->mode,
|
|
|
|
a->sha1, a->mode,
|
|
|
|
b->sha1, b->mode,
|
|
|
|
ci->branch1, ci->branch2);
|
2008-08-12 16:45:14 +00:00
|
|
|
/*
|
2011-08-12 05:20:13 +00:00
|
|
|
* FIXME: For rename/add-source conflicts (if we could detect
|
|
|
|
* such), this is wrong. We should instead find a unique
|
|
|
|
* pathname and then either rename the add-source file to that
|
|
|
|
* unique path, or use that unique path instead of src here.
|
2008-08-12 16:45:14 +00:00
|
|
|
*/
|
2011-08-12 05:20:14 +00:00
|
|
|
update_file(o, 0, mfi.sha, mfi.mode, one->path);
|
2010-09-20 08:29:00 +00:00
|
|
|
|
2011-08-12 05:20:29 +00:00
|
|
|
/*
|
|
|
|
* Above, we put the merged content at the merge-base's
|
|
|
|
* path. Now we usually need to delete both a->path and
|
|
|
|
* b->path. However, the rename on each side of the merge
|
|
|
|
* could also be involved in a rename/add conflict. In
|
|
|
|
* such cases, we should keep the added file around,
|
|
|
|
* resolving the conflict at that path in its favor.
|
|
|
|
*/
|
|
|
|
add = filespec_from_entry(&other, ci->dst_entry1, 2 ^ 1);
|
|
|
|
if (add)
|
|
|
|
update_file(o, 0, add->sha1, add->mode, a->path);
|
|
|
|
else
|
|
|
|
remove_file_from_cache(a->path);
|
|
|
|
add = filespec_from_entry(&other, ci->dst_entry2, 3 ^ 1);
|
|
|
|
if (add)
|
|
|
|
update_file(o, 0, add->sha1, add->mode, b->path);
|
|
|
|
else
|
|
|
|
remove_file_from_cache(b->path);
|
2008-08-12 16:45:14 +00:00
|
|
|
} else {
|
2011-08-12 05:20:22 +00:00
|
|
|
handle_file(o, a, 2, ci);
|
|
|
|
handle_file(o, b, 3, ci);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-20 08:28:48 +00:00
|
|
|
static void conflict_rename_rename_2to1(struct merge_options *o,
|
2011-08-12 05:20:15 +00:00
|
|
|
struct rename_conflict_info *ci)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
2011-08-12 05:20:15 +00:00
|
|
|
/* Two files, a & b, were renamed to the same thing, c. */
|
|
|
|
struct diff_filespec *a = ci->pair1->one;
|
|
|
|
struct diff_filespec *b = ci->pair2->one;
|
|
|
|
struct diff_filespec *c1 = ci->pair1->two;
|
|
|
|
struct diff_filespec *c2 = ci->pair2->two;
|
|
|
|
char *path = c1->path; /* == c2->path */
|
merge-recursive: Consider modifications in rename/rename(2to1) conflicts
Our previous conflict resolution for renaming two different files to the
same name ignored the fact that each of those files may have modifications
from both sides of history to consider. We need to do a three-way merge
for each of those files, and then handle the conflict of both sets of
merged contents trying to be recorded with the same name.
It is important to note that this changes our strategy in the recursive
case. After doing a three-way content merge of each of the files
involved, we still are faced with the fact that we are trying to put both
of the results (including conflict markers) into the same path. We could
do another two-way merge, but I think that becomes confusing. Also,
taking a hint from the modify/delete and rename/delete cases we handled
earlier, a more useful "common ground" would be to keep the three-way
content merge but record it with the original filename. The renames can
still be detected, we just allow it to be done in the o->call_depth=0
case. This seems to result in simpler & easier to understand merge
conflicts as well, as evidenced by some of the changes needed in our
testsuite in t6036. (However, it should be noted that this change will
cause problems those renames also occur along with a file being added
whose name matches the source of the rename. Since git currently cannot
detect rename/add-source situations, though, this codepath is not
currently used for those cases anyway.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-12 05:20:18 +00:00
|
|
|
struct merge_file_info mfi_c1;
|
|
|
|
struct merge_file_info mfi_c2;
|
2011-08-12 05:20:15 +00:00
|
|
|
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 1, _("CONFLICT (rename/rename): "
|
2011-08-12 05:20:15 +00:00
|
|
|
"Rename %s->%s in %s. "
|
2012-07-25 14:53:13 +00:00
|
|
|
"Rename %s->%s in %s"),
|
2011-08-12 05:20:15 +00:00
|
|
|
a->path, c1->path, ci->branch1,
|
|
|
|
b->path, c2->path, ci->branch2);
|
|
|
|
|
|
|
|
remove_file(o, 1, a->path, would_lose_untracked(a->path));
|
|
|
|
remove_file(o, 1, b->path, would_lose_untracked(b->path));
|
|
|
|
|
merge-recursive: Consider modifications in rename/rename(2to1) conflicts
Our previous conflict resolution for renaming two different files to the
same name ignored the fact that each of those files may have modifications
from both sides of history to consider. We need to do a three-way merge
for each of those files, and then handle the conflict of both sets of
merged contents trying to be recorded with the same name.
It is important to note that this changes our strategy in the recursive
case. After doing a three-way content merge of each of the files
involved, we still are faced with the fact that we are trying to put both
of the results (including conflict markers) into the same path. We could
do another two-way merge, but I think that becomes confusing. Also,
taking a hint from the modify/delete and rename/delete cases we handled
earlier, a more useful "common ground" would be to keep the three-way
content merge but record it with the original filename. The renames can
still be detected, we just allow it to be done in the o->call_depth=0
case. This seems to result in simpler & easier to understand merge
conflicts as well, as evidenced by some of the changes needed in our
testsuite in t6036. (However, it should be noted that this change will
cause problems those renames also occur along with a file being added
whose name matches the source of the rename. Since git currently cannot
detect rename/add-source situations, though, this codepath is not
currently used for those cases anyway.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-12 05:20:18 +00:00
|
|
|
mfi_c1 = merge_file_special_markers(o, a, c1, &ci->ren1_other,
|
|
|
|
o->branch1, c1->path,
|
|
|
|
o->branch2, ci->ren1_other.path);
|
|
|
|
mfi_c2 = merge_file_special_markers(o, b, &ci->ren2_other, c2,
|
|
|
|
o->branch1, ci->ren2_other.path,
|
|
|
|
o->branch2, c2->path);
|
|
|
|
|
2011-08-12 05:20:04 +00:00
|
|
|
if (o->call_depth) {
|
merge-recursive: Consider modifications in rename/rename(2to1) conflicts
Our previous conflict resolution for renaming two different files to the
same name ignored the fact that each of those files may have modifications
from both sides of history to consider. We need to do a three-way merge
for each of those files, and then handle the conflict of both sets of
merged contents trying to be recorded with the same name.
It is important to note that this changes our strategy in the recursive
case. After doing a three-way content merge of each of the files
involved, we still are faced with the fact that we are trying to put both
of the results (including conflict markers) into the same path. We could
do another two-way merge, but I think that becomes confusing. Also,
taking a hint from the modify/delete and rename/delete cases we handled
earlier, a more useful "common ground" would be to keep the three-way
content merge but record it with the original filename. The renames can
still be detected, we just allow it to be done in the o->call_depth=0
case. This seems to result in simpler & easier to understand merge
conflicts as well, as evidenced by some of the changes needed in our
testsuite in t6036. (However, it should be noted that this change will
cause problems those renames also occur along with a file being added
whose name matches the source of the rename. Since git currently cannot
detect rename/add-source situations, though, this codepath is not
currently used for those cases anyway.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-12 05:20:18 +00:00
|
|
|
/*
|
|
|
|
* If mfi_c1.clean && mfi_c2.clean, then it might make
|
|
|
|
* sense to do a two-way merge of those results. But, I
|
|
|
|
* think in all cases, it makes sense to have the virtual
|
|
|
|
* merge base just undo the renames; they can be detected
|
|
|
|
* again later for the non-recursive merge.
|
|
|
|
*/
|
|
|
|
remove_file(o, 0, path, 0);
|
|
|
|
update_file(o, 0, mfi_c1.sha, mfi_c1.mode, a->path);
|
|
|
|
update_file(o, 0, mfi_c2.sha, mfi_c2.mode, b->path);
|
2011-08-12 05:20:04 +00:00
|
|
|
} else {
|
2011-08-12 05:20:15 +00:00
|
|
|
char *new_path1 = unique_path(o, path, ci->branch1);
|
|
|
|
char *new_path2 = unique_path(o, path, ci->branch2);
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 1, _("Renaming %s to %s and %s to %s instead"),
|
2011-08-12 05:20:15 +00:00
|
|
|
a->path, new_path1, b->path, new_path2);
|
2011-08-12 05:20:04 +00:00
|
|
|
remove_file(o, 0, path, 0);
|
merge-recursive: Consider modifications in rename/rename(2to1) conflicts
Our previous conflict resolution for renaming two different files to the
same name ignored the fact that each of those files may have modifications
from both sides of history to consider. We need to do a three-way merge
for each of those files, and then handle the conflict of both sets of
merged contents trying to be recorded with the same name.
It is important to note that this changes our strategy in the recursive
case. After doing a three-way content merge of each of the files
involved, we still are faced with the fact that we are trying to put both
of the results (including conflict markers) into the same path. We could
do another two-way merge, but I think that becomes confusing. Also,
taking a hint from the modify/delete and rename/delete cases we handled
earlier, a more useful "common ground" would be to keep the three-way
content merge but record it with the original filename. The renames can
still be detected, we just allow it to be done in the o->call_depth=0
case. This seems to result in simpler & easier to understand merge
conflicts as well, as evidenced by some of the changes needed in our
testsuite in t6036. (However, it should be noted that this change will
cause problems those renames also occur along with a file being added
whose name matches the source of the rename. Since git currently cannot
detect rename/add-source situations, though, this codepath is not
currently used for those cases anyway.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-12 05:20:18 +00:00
|
|
|
update_file(o, 0, mfi_c1.sha, mfi_c1.mode, new_path1);
|
|
|
|
update_file(o, 0, mfi_c2.sha, mfi_c2.mode, new_path2);
|
2011-08-12 05:20:04 +00:00
|
|
|
free(new_path2);
|
|
|
|
free(new_path1);
|
|
|
|
}
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
|
2008-08-25 14:25:57 +00:00
|
|
|
static int process_renames(struct merge_options *o,
|
|
|
|
struct string_list *a_renames,
|
|
|
|
struct string_list *b_renames)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
|
|
|
int clean_merge = 1, i, j;
|
2010-07-04 19:46:19 +00:00
|
|
|
struct string_list a_by_dst = STRING_LIST_INIT_NODUP;
|
|
|
|
struct string_list b_by_dst = STRING_LIST_INIT_NODUP;
|
2008-08-12 16:45:14 +00:00
|
|
|
const struct rename *sre;
|
|
|
|
|
|
|
|
for (i = 0; i < a_renames->nr; i++) {
|
|
|
|
sre = a_renames->items[i].util;
|
2010-06-25 23:41:35 +00:00
|
|
|
string_list_insert(&a_by_dst, sre->pair->two->path)->util
|
2011-08-12 05:20:04 +00:00
|
|
|
= (void *)sre;
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
for (i = 0; i < b_renames->nr; i++) {
|
|
|
|
sre = b_renames->items[i].util;
|
2010-06-25 23:41:35 +00:00
|
|
|
string_list_insert(&b_by_dst, sre->pair->two->path)->util
|
2011-08-12 05:20:04 +00:00
|
|
|
= (void *)sre;
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0, j = 0; i < a_renames->nr || j < b_renames->nr;) {
|
2009-03-15 21:01:20 +00:00
|
|
|
struct string_list *renames1, *renames2Dst;
|
2008-08-12 16:45:14 +00:00
|
|
|
struct rename *ren1 = NULL, *ren2 = NULL;
|
|
|
|
const char *branch1, *branch2;
|
|
|
|
const char *ren1_src, *ren1_dst;
|
2011-08-12 05:20:15 +00:00
|
|
|
struct string_list_item *lookup;
|
2008-08-12 16:45:14 +00:00
|
|
|
|
|
|
|
if (i >= a_renames->nr) {
|
|
|
|
ren2 = b_renames->items[j++].util;
|
|
|
|
} else if (j >= b_renames->nr) {
|
|
|
|
ren1 = a_renames->items[i++].util;
|
|
|
|
} else {
|
2009-03-15 21:01:20 +00:00
|
|
|
int compare = strcmp(a_renames->items[i].string,
|
|
|
|
b_renames->items[j].string);
|
2008-08-12 16:45:14 +00:00
|
|
|
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 */
|
|
|
|
if (ren1) {
|
|
|
|
renames1 = a_renames;
|
|
|
|
renames2Dst = &b_by_dst;
|
2008-08-25 14:25:57 +00:00
|
|
|
branch1 = o->branch1;
|
|
|
|
branch2 = o->branch2;
|
2008-08-12 16:45:14 +00:00
|
|
|
} else {
|
|
|
|
struct rename *tmp;
|
|
|
|
renames1 = b_renames;
|
|
|
|
renames2Dst = &a_by_dst;
|
2008-08-25 14:25:57 +00:00
|
|
|
branch1 = o->branch2;
|
|
|
|
branch2 = o->branch1;
|
2008-08-12 16:45:14 +00:00
|
|
|
tmp = ren2;
|
|
|
|
ren2 = ren1;
|
|
|
|
ren1 = tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ren1->processed)
|
|
|
|
continue;
|
|
|
|
ren1->processed = 1;
|
|
|
|
ren1->dst_entry->processed = 1;
|
2011-08-12 05:20:05 +00:00
|
|
|
/* BUG: We should only mark src_entry as processed if we
|
|
|
|
* are not dealing with a rename + add-source case.
|
|
|
|
*/
|
2008-08-12 16:45:14 +00:00
|
|
|
ren1->src_entry->processed = 1;
|
|
|
|
|
|
|
|
ren1_src = ren1->pair->one->path;
|
|
|
|
ren1_dst = ren1->pair->two->path;
|
|
|
|
|
|
|
|
if (ren2) {
|
2011-08-12 05:20:15 +00:00
|
|
|
/* One file renamed on both sides */
|
2008-08-12 16:45:14 +00:00
|
|
|
const char *ren2_src = ren2->pair->one->path;
|
|
|
|
const char *ren2_dst = ren2->pair->two->path;
|
2011-08-12 05:20:08 +00:00
|
|
|
enum rename_type rename_type;
|
2008-08-12 16:45:14 +00:00
|
|
|
if (strcmp(ren1_src, ren2_src) != 0)
|
2011-08-12 05:20:15 +00:00
|
|
|
die("ren1_src != ren2_src");
|
2008-08-12 16:45:14 +00:00
|
|
|
ren2->dst_entry->processed = 1;
|
|
|
|
ren2->processed = 1;
|
|
|
|
if (strcmp(ren1_dst, ren2_dst) != 0) {
|
2011-08-12 05:20:08 +00:00
|
|
|
rename_type = RENAME_ONE_FILE_TO_TWO;
|
2011-08-12 05:20:15 +00:00
|
|
|
clean_merge = 0;
|
2008-08-12 16:45:14 +00:00
|
|
|
} else {
|
2011-08-12 05:20:08 +00:00
|
|
|
rename_type = RENAME_ONE_FILE_TO_ONE;
|
2011-08-12 05:20:05 +00:00
|
|
|
/* BUG: We should only remove ren1_src in
|
|
|
|
* the base stage (think of rename +
|
|
|
|
* add-source cases).
|
|
|
|
*/
|
2008-09-02 21:53:47 +00:00
|
|
|
remove_file(o, 1, ren1_src, 1);
|
2011-08-12 05:20:02 +00:00
|
|
|
update_entry(ren1->dst_entry,
|
|
|
|
ren1->pair->one,
|
|
|
|
ren1->pair->two,
|
|
|
|
ren2->pair->two);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
2011-08-12 05:20:08 +00:00
|
|
|
setup_rename_conflict_info(rename_type,
|
|
|
|
ren1->pair,
|
|
|
|
ren2->pair,
|
|
|
|
branch1,
|
|
|
|
branch2,
|
|
|
|
ren1->dst_entry,
|
2011-08-12 05:20:16 +00:00
|
|
|
ren2->dst_entry,
|
|
|
|
o,
|
|
|
|
NULL,
|
|
|
|
NULL);
|
2011-08-12 05:20:15 +00:00
|
|
|
} else if ((lookup = string_list_lookup(renames2Dst, ren1_dst))) {
|
|
|
|
/* Two different files renamed to the same thing */
|
|
|
|
char *ren2_dst;
|
|
|
|
ren2 = lookup->util;
|
|
|
|
ren2_dst = ren2->pair->two->path;
|
|
|
|
if (strcmp(ren1_dst, ren2_dst) != 0)
|
|
|
|
die("ren1_dst != ren2_dst");
|
|
|
|
|
|
|
|
clean_merge = 0;
|
|
|
|
ren2->processed = 1;
|
|
|
|
/*
|
|
|
|
* BUG: We should only mark src_entry as processed
|
|
|
|
* if we are not dealing with a rename + add-source
|
|
|
|
* case.
|
|
|
|
*/
|
|
|
|
ren2->src_entry->processed = 1;
|
|
|
|
|
|
|
|
setup_rename_conflict_info(RENAME_TWO_FILES_TO_ONE,
|
|
|
|
ren1->pair,
|
|
|
|
ren2->pair,
|
|
|
|
branch1,
|
|
|
|
branch2,
|
|
|
|
ren1->dst_entry,
|
2011-08-12 05:20:16 +00:00
|
|
|
ren2->dst_entry,
|
|
|
|
o,
|
|
|
|
ren1->src_entry,
|
|
|
|
ren2->src_entry);
|
|
|
|
|
2008-08-12 16:45:14 +00:00
|
|
|
} else {
|
|
|
|
/* Renamed in 1, maybe changed in 2 */
|
|
|
|
/* we only use sha1 and mode of these */
|
|
|
|
struct diff_filespec src_other, dst_other;
|
2010-09-20 08:28:47 +00:00
|
|
|
int try_merge;
|
2008-08-12 16:45:14 +00:00
|
|
|
|
2010-09-20 08:28:47 +00:00
|
|
|
/*
|
|
|
|
* unpack_trees loads entries from common-commit
|
|
|
|
* into stage 1, from head-commit into stage 2, and
|
|
|
|
* from merge-commit into stage 3. We keep track
|
|
|
|
* of which side corresponds to the rename.
|
|
|
|
*/
|
|
|
|
int renamed_stage = a_renames == renames1 ? 2 : 3;
|
|
|
|
int other_stage = a_renames == renames1 ? 3 : 2;
|
2008-08-12 16:45:14 +00:00
|
|
|
|
2011-08-12 05:20:05 +00:00
|
|
|
/* BUG: We should only remove ren1_src in the base
|
|
|
|
* stage and in other_stage (think of rename +
|
|
|
|
* add-source case).
|
|
|
|
*/
|
merge-recursive: Fix deletion of untracked file in rename/delete conflicts
In the recursive case (o->call_depth > 0), we do not modify the working
directory. However, when o->call_depth==0, file renames can mean we need
to delete the old filename from the working copy. Since there have been
lots of changes and mistakes here, let's go through the details. Let's
start with a simple explanation of what we are trying to achieve:
Original goal: If a file is renamed on the side of history being merged
into head, the filename serving as the source of that rename needs to be
removed from the working directory.
The path to getting the above statement implemented in merge-recursive took
several steps. The relevant bits of code may be instructive to keep in
mind for the explanation, especially since an English-only description
involves double negatives that are hard to follow. These bits of code are:
int remove_file(..., const char *path, int no_wd)
{
...
int update_working_directory = !o->call_depth && !no_wd;
and
remove_file(o, 1, ren1_src, <expression>);
Where the choice for <expression> has morphed over time:
65ac6e9 (merge-recursive: adjust to loosened "working file clobbered"
check 2006-10-27), introduced the "no_wd" parameter to remove_file() and
used "1" for <expression>. This meant ren1_src was never deleted, leaving
it around in the working copy.
In 8371234 (Remove uncontested renamed files during merge. 2006-12-13),
<expression> was changed to "index_only" (where index_only ==
!!o->call_depth; see b7fa51da). This was equivalent to using "0" for
<expression> (due to the early logic in remove_file), and is orthogonal to
the condition we actually want to check at this point; it resulted in the
source file being removed except when index_only was false. This was
problematic because the file could have been renamed on the side of history
including head, in which case ren1_src could correspond to an untracked
file that should not be deleted.
In 183d797 (Keep untracked files not involved in a merge. 2007-02-04),
<expression> was changed to "index_only || stage == 3". While this gives
correct behavior, the "index_only ||" portion of <expression> is
unnecessary and makes the code slightly harder to follow.
There were also two further changes to this expression, though without
any change in behavior. First in b7fa51d (merge-recursive: get rid of the
index_only global variable 2008-09-02), it was changed to "o->call_depth
|| stage == 3". (index_only == !!o->call_depth). Later, in 41d70bd6
(merge-recursive: Small code clarification -- variable name and comments),
this was changed to "o->call_depth || renamed_stage == 2" (where stage was
renamed to other_stage and renamed_stage == other_stage ^ 1).
So we ended with <expression> being "o->call_depth || renamed_stage == 2".
But the "o->call_depth ||" piece was unnecessary. We can remove it,
leaving us with <expression> being "renamed_stage == 2". This doesn't
change behavior at all, but it makes the code clearer. Which is good,
because it's about to get uglier.
Corrected goal: If a file is renamed on the side of history being merged
into head, the filename serving as the source of that rename needs to be
removed from the working directory *IF* that file is tracked in head AND
the file tracked in head is related to the original file.
Note that the only difference between the original goal and the corrected
goal is the two extra conditions added at the end. The first condition is
relevant in a rename/delete conflict. If the file was deleted on the
HEAD side of the merge and an untracked file of the same name was added to
the working copy, then without that extra condition the untracked file
will be erroneously deleted. This changes <expression> to "renamed_stage
== 2 || !was_tracked(ren1_src)".
The second additional condition is relevant in two cases.
The first case the second condition can occur is when a file is deleted
and a completely different file is added with the same name. To my
knowledge, merge-recursive has no mechanism for detecting deleted-and-
replaced-by-different-file cases, so I am simply punting on this
possibility.
The second case for the second condition to occur is when there is a
rename/rename/add-source conflict. That is, when the original file was
renamed on both sides of history AND the original filename is being
re-used by some unrelated (but tracked) content. This case also presents
some additional difficulties for us since we cannot currently detect these
rename/rename/add-source conflicts; as long as the rename detection logic
"optimizes" by ignoring filenames that are present at both ends of the
diff, these conflicts will go unnoticed. However, rename/rename conflicts
are handled by an entirely separate codepath not being discussed here, so
this case is not relevant for the line of code under consideration.
In summary:
Change <expression> from "o->call_depth || renamed_stage == 2" to
"renamed_stage == 2 || !was_tracked(ren1_src)", in order to remove
unnecessary code and avoid deleting untracked files.
96 lines of explanation in the changelog to describe a one-line fix...
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-12 05:20:03 +00:00
|
|
|
remove_file(o, 1, ren1_src,
|
|
|
|
renamed_stage == 2 || !was_tracked(ren1_src));
|
2008-08-12 16:45:14 +00:00
|
|
|
|
2010-09-20 08:28:47 +00:00
|
|
|
hashcpy(src_other.sha1, ren1->src_entry->stages[other_stage].sha);
|
|
|
|
src_other.mode = ren1->src_entry->stages[other_stage].mode;
|
|
|
|
hashcpy(dst_other.sha1, ren1->dst_entry->stages[other_stage].sha);
|
|
|
|
dst_other.mode = ren1->dst_entry->stages[other_stage].mode;
|
2008-08-12 16:45:14 +00:00
|
|
|
try_merge = 0;
|
|
|
|
|
merge-recursive: D/F conflicts where was_a_dir/file -> was_a_dir
In merge-recursive.c, whenever there was a rename where a file name on one
side of the rename matches a directory name on the other side of the merge,
then the very first check that
string_list_has_string(&o->current_directory_set, ren1_dst)
would trigger forcing it into marking it as a rename/directory conflict.
However, if the path is only renamed on one side and a simple three-way
merge between the separate files resolves cleanly, then we don't need to
mark it as a rename/directory conflict. So, we can simply move the check
for rename/directory conflicts after we've verified that there isn't a
rename/rename conflict and that a threeway content merge doesn't work.
This changes the particular error message one gets in the case where the
directory name that a file on one side of the rename matches is not also
part of the rename pair. For example, with commits containing the files:
COMMON -> (HEAD, MERGE )
--------- --------------- -------
sub/file1 -> (sub/file1, newsub)
<NULL> -> (newsub/newfile, <NULL>)
then previously when one tried to merge MERGE into HEAD, one would get
CONFLICT (rename/directory): Rename sub/file1->newsub in HEAD directory newsub added in merge
Renaming sub/file1 to newsub~HEAD instead
Adding newsub/newfile
Automatic merge failed; fix conflicts and then commit the result.
After this patch, the error message will instead become:
Removing newsub
Adding newsub/newfile
CONFLICT (file/directory): There is a directory with name newsub in merge. Adding newsub as newsub~HEAD
Automatic merge failed; fix conflicts and then commit the result.
That makes more sense to me, because git can't know that there's a conflict
until after it's tried resolving paths involving newsub/newfile to see if
they are still in the way at the end (and if newsub/newfile is not in the
way at the end, there should be no conflict at all, which did not hold with
git previously).
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-09-08 06:40:41 +00:00
|
|
|
if (sha_eq(src_other.sha1, null_sha1)) {
|
2011-08-12 05:20:08 +00:00
|
|
|
setup_rename_conflict_info(RENAME_DELETE,
|
|
|
|
ren1->pair,
|
|
|
|
NULL,
|
|
|
|
branch1,
|
|
|
|
branch2,
|
|
|
|
ren1->dst_entry,
|
2011-08-12 05:20:16 +00:00
|
|
|
NULL,
|
|
|
|
o,
|
|
|
|
NULL,
|
2011-08-12 05:20:08 +00:00
|
|
|
NULL);
|
2010-09-01 20:15:32 +00:00
|
|
|
} else if ((dst_other.mode == ren1->pair->two->mode) &&
|
|
|
|
sha_eq(dst_other.sha1, ren1->pair->two->sha1)) {
|
2011-08-12 05:20:27 +00:00
|
|
|
/*
|
|
|
|
* Added file on the other side identical to
|
|
|
|
* the file being renamed: clean merge.
|
|
|
|
* Also, there is no need to overwrite the
|
|
|
|
* file already in the working copy, so call
|
|
|
|
* update_file_flags() instead of
|
|
|
|
* update_file().
|
|
|
|
*/
|
|
|
|
update_file_flags(o,
|
|
|
|
ren1->pair->two->sha1,
|
|
|
|
ren1->pair->two->mode,
|
|
|
|
ren1_dst,
|
|
|
|
1, /* update_cache */
|
|
|
|
0 /* update_wd */);
|
2008-08-12 16:45:14 +00:00
|
|
|
} else if (!sha_eq(dst_other.sha1, null_sha1)) {
|
|
|
|
clean_merge = 0;
|
|
|
|
try_merge = 1;
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 1, _("CONFLICT (rename/add): Rename %s->%s in %s. "
|
|
|
|
"%s added in %s"),
|
2008-08-12 16:45:14 +00:00
|
|
|
ren1_src, ren1_dst, branch1,
|
|
|
|
ren1_dst, branch2);
|
2009-07-31 00:38:15 +00:00
|
|
|
if (o->call_depth) {
|
|
|
|
struct merge_file_info mfi;
|
2012-12-06 23:08:01 +00:00
|
|
|
mfi = merge_file_one(o, ren1_dst, null_sha1, 0,
|
2011-08-12 05:20:12 +00:00
|
|
|
ren1->pair->two->sha1, ren1->pair->two->mode,
|
|
|
|
dst_other.sha1, dst_other.mode,
|
|
|
|
branch1, branch2);
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 1, _("Adding merged %s"), ren1_dst);
|
2011-08-12 05:20:12 +00:00
|
|
|
update_file(o, 0, mfi.sha, mfi.mode, ren1_dst);
|
merge-recursive: Avoid doubly merging rename/add conflict contents
When a commit moves A to B while another commit created B (or moved C to
B), and these two different commits serve as different merge-bases for a
later merge, c94736a (merge-recursive: don't segfault while handling
rename clashes 2009-07-30) added some special code to avoid segfaults.
Since that commit, the two versions of B are merged in place (which could
be potentially conflicting) and the intermediate result is used as the
virtual ancestor.
However, right before this special merge, try_merge was turned on, meaning
that process_renames() would try an alternative merge that ignores the
'add' part of the conflict, and, if the merge is clean, store that as the
new virtual ancestor. This could cause incorrect merging of criss-cross
merges; it would typically result in just recording a slightly confusing
merge base, but in some cases it could cause silent acceptance of one side
of a merge as the final resolution when a conflict should have been
flagged.
When we do a special merge for such a rename/add conflict between
merge-bases, turn try_merge off to avoid an inappropriate second merge.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-09-20 08:28:59 +00:00
|
|
|
try_merge = 0;
|
2009-07-31 00:38:15 +00:00
|
|
|
} else {
|
2011-08-12 05:19:53 +00:00
|
|
|
char *new_path = unique_path(o, ren1_dst, branch2);
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 1, _("Adding as %s instead"), new_path);
|
2009-07-31 00:38:15 +00:00
|
|
|
update_file(o, 0, dst_other.sha1, dst_other.mode, new_path);
|
2011-08-12 05:19:53 +00:00
|
|
|
free(new_path);
|
2009-07-31 00:38:15 +00:00
|
|
|
}
|
2008-08-12 16:45:14 +00:00
|
|
|
} else
|
|
|
|
try_merge = 1;
|
|
|
|
|
|
|
|
if (try_merge) {
|
2008-08-25 14:25:57 +00:00
|
|
|
struct diff_filespec *one, *a, *b;
|
2008-08-12 16:45:14 +00:00
|
|
|
src_other.path = (char *)ren1_src;
|
|
|
|
|
2008-08-25 14:25:57 +00:00
|
|
|
one = ren1->pair->one;
|
2008-08-12 16:45:14 +00:00
|
|
|
if (a_renames == renames1) {
|
|
|
|
a = ren1->pair->two;
|
|
|
|
b = &src_other;
|
|
|
|
} else {
|
|
|
|
b = ren1->pair->two;
|
|
|
|
a = &src_other;
|
|
|
|
}
|
2011-08-12 05:20:02 +00:00
|
|
|
update_entry(ren1->dst_entry, one, a, b);
|
2011-08-12 05:20:08 +00:00
|
|
|
setup_rename_conflict_info(RENAME_NORMAL,
|
|
|
|
ren1->pair,
|
|
|
|
NULL,
|
|
|
|
branch1,
|
|
|
|
NULL,
|
|
|
|
ren1->dst_entry,
|
2011-08-12 05:20:16 +00:00
|
|
|
NULL,
|
|
|
|
o,
|
|
|
|
NULL,
|
2011-08-12 05:20:08 +00:00
|
|
|
NULL);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
string_list_clear(&a_by_dst, 0);
|
|
|
|
string_list_clear(&b_by_dst, 0);
|
|
|
|
|
|
|
|
return clean_merge;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned char *stage_sha(const unsigned char *sha, unsigned mode)
|
|
|
|
{
|
|
|
|
return (is_null_sha1(sha) || mode == 0) ? NULL: (unsigned char *)sha;
|
|
|
|
}
|
|
|
|
|
2010-07-02 19:20:48 +00:00
|
|
|
static int read_sha1_strbuf(const unsigned char *sha1, struct strbuf *dst)
|
|
|
|
{
|
|
|
|
void *buf;
|
|
|
|
enum object_type type;
|
|
|
|
unsigned long size;
|
|
|
|
buf = read_sha1_file(sha1, &type, &size);
|
|
|
|
if (!buf)
|
2012-07-25 14:53:13 +00:00
|
|
|
return error(_("cannot read object %s"), sha1_to_hex(sha1));
|
2010-07-02 19:20:48 +00:00
|
|
|
if (type != OBJ_BLOB) {
|
|
|
|
free(buf);
|
2012-07-25 14:53:13 +00:00
|
|
|
return error(_("object %s is not a blob"), sha1_to_hex(sha1));
|
2010-07-02 19:20:48 +00:00
|
|
|
}
|
|
|
|
strbuf_attach(dst, buf, size, size + 1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int blob_unchanged(const unsigned char *o_sha,
|
|
|
|
const unsigned char *a_sha,
|
2010-08-05 11:13:49 +00:00
|
|
|
int renormalize, const char *path)
|
2010-07-02 19:20:48 +00:00
|
|
|
{
|
|
|
|
struct strbuf o = STRBUF_INIT;
|
|
|
|
struct strbuf a = STRBUF_INIT;
|
|
|
|
int ret = 0; /* assume changed for safety */
|
|
|
|
|
|
|
|
if (sha_eq(o_sha, a_sha))
|
|
|
|
return 1;
|
2010-08-05 11:13:49 +00:00
|
|
|
if (!renormalize)
|
2010-07-02 19:20:48 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
assert(o_sha && a_sha);
|
|
|
|
if (read_sha1_strbuf(o_sha, &o) || read_sha1_strbuf(a_sha, &a))
|
|
|
|
goto error_return;
|
|
|
|
/*
|
|
|
|
* Note: binary | is used so that both renormalizations are
|
|
|
|
* performed. Comparison can be skipped if both files are
|
|
|
|
* unchanged since their sha1s have already been compared.
|
|
|
|
*/
|
|
|
|
if (renormalize_buffer(path, o.buf, o.len, &o) |
|
|
|
|
renormalize_buffer(path, a.buf, o.len, &a))
|
|
|
|
ret = (o.len == a.len && !memcmp(o.buf, a.buf, o.len));
|
|
|
|
|
|
|
|
error_return:
|
|
|
|
strbuf_release(&o);
|
|
|
|
strbuf_release(&a);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-08-12 05:20:19 +00:00
|
|
|
static void handle_modify_delete(struct merge_options *o,
|
2010-09-20 08:28:51 +00:00
|
|
|
const char *path,
|
2011-08-12 05:20:11 +00:00
|
|
|
unsigned char *o_sha, int o_mode,
|
2010-09-20 08:28:51 +00:00
|
|
|
unsigned char *a_sha, int a_mode,
|
|
|
|
unsigned char *b_sha, int b_mode)
|
|
|
|
{
|
2011-08-12 05:20:19 +00:00
|
|
|
handle_change_delete(o,
|
|
|
|
path,
|
|
|
|
o_sha, o_mode,
|
|
|
|
a_sha, a_mode,
|
|
|
|
b_sha, b_mode,
|
2012-07-25 14:53:13 +00:00
|
|
|
_("modify"), _("modified"));
|
2010-09-20 08:28:51 +00:00
|
|
|
}
|
|
|
|
|
2010-09-20 08:28:52 +00:00
|
|
|
static int merge_content(struct merge_options *o,
|
|
|
|
const char *path,
|
|
|
|
unsigned char *o_sha, int o_mode,
|
|
|
|
unsigned char *a_sha, int a_mode,
|
2010-09-20 08:28:58 +00:00
|
|
|
unsigned char *b_sha, int b_mode,
|
2011-08-12 05:20:08 +00:00
|
|
|
struct rename_conflict_info *rename_conflict_info)
|
2010-09-20 08:28:52 +00:00
|
|
|
{
|
2012-07-25 14:53:13 +00:00
|
|
|
const char *reason = _("content");
|
merge-recursive: When we detect we can skip an update, actually skip it
In 882fd11 (merge-recursive: Delay content merging for renames 2010-09-20),
there was code that checked for whether we could skip updating a file in
the working directory, based on whether the merged version matched the
current working copy. Due to the desire to handle directory/file conflicts
that were resolvable, that commit deferred content merging by first
updating the index with the unmerged entries and then moving the actual
merging (along with the skip-the-content-update check) to another function
that ran later in the merge process. As part moving the content merging
code, a bug was introduced such that although the message about skipping
the update would be printed (whenever GIT_MERGE_VERBOSITY was sufficiently
high), the file would be unconditionally updated in the working copy
anyway.
When we detect that the file does not need to be updated in the working
copy, update the index appropriately and then return early before updating
the working copy.
Note that there was a similar change in b2c8c0a (merge-recursive: When we
detect we can skip an update, actually skip it 2011-02-28), but it was
reverted by 6db4105 (Revert "Merge branch 'en/merge-recursive'"
2011-05-19) since it did not fix both of the relevant types of unnecessary
update breakages and, worse, it made use of some band-aids that caused
other problems. The reason this change works is due to the changes earlier
in this series to (a) record_df_conflict_files instead of just unlinking
them early, (b) allowing make_room_for_path() to remove D/F entries,
(c) the splitting of update_stages_and_entry() to have its functionality
called at different points, and (d) making the pathnames of the files
involved in the merge available to merge_content().
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-12 05:20:10 +00:00
|
|
|
const char *path1 = NULL, *path2 = NULL;
|
2010-09-20 08:28:52 +00:00
|
|
|
struct merge_file_info mfi;
|
|
|
|
struct diff_filespec one, a, b;
|
2010-09-20 08:29:07 +00:00
|
|
|
unsigned df_conflict_remains = 0;
|
2010-09-20 08:28:52 +00:00
|
|
|
|
|
|
|
if (!o_sha) {
|
2012-07-25 14:53:13 +00:00
|
|
|
reason = _("add/add");
|
2010-09-20 08:28:52 +00:00
|
|
|
o_sha = (unsigned char *)null_sha1;
|
|
|
|
}
|
|
|
|
one.path = a.path = b.path = (char *)path;
|
|
|
|
hashcpy(one.sha1, o_sha);
|
|
|
|
one.mode = o_mode;
|
|
|
|
hashcpy(a.sha1, a_sha);
|
|
|
|
a.mode = a_mode;
|
|
|
|
hashcpy(b.sha1, b_sha);
|
|
|
|
b.mode = b_mode;
|
|
|
|
|
2011-08-12 05:20:09 +00:00
|
|
|
if (rename_conflict_info) {
|
|
|
|
struct diff_filepair *pair1 = rename_conflict_info->pair1;
|
|
|
|
|
|
|
|
path1 = (o->branch1 == rename_conflict_info->branch1) ?
|
|
|
|
pair1->two->path : pair1->one->path;
|
|
|
|
/* If rename_conflict_info->pair2 != NULL, we are in
|
|
|
|
* RENAME_ONE_FILE_TO_ONE case. Otherwise, we have a
|
|
|
|
* normal rename.
|
|
|
|
*/
|
|
|
|
path2 = (rename_conflict_info->pair2 ||
|
|
|
|
o->branch2 == rename_conflict_info->branch1) ?
|
|
|
|
pair1->two->path : pair1->one->path;
|
|
|
|
|
|
|
|
if (dir_in_way(path, !o->call_depth))
|
|
|
|
df_conflict_remains = 1;
|
2010-09-20 08:29:07 +00:00
|
|
|
}
|
2011-08-12 05:20:17 +00:00
|
|
|
mfi = merge_file_special_markers(o, &one, &a, &b,
|
|
|
|
o->branch1, path1,
|
|
|
|
o->branch2, path2);
|
2010-09-20 08:29:07 +00:00
|
|
|
|
|
|
|
if (mfi.clean && !df_conflict_remains &&
|
merge-recursive: When we detect we can skip an update, actually skip it
In 882fd11 (merge-recursive: Delay content merging for renames 2010-09-20),
there was code that checked for whether we could skip updating a file in
the working directory, based on whether the merged version matched the
current working copy. Due to the desire to handle directory/file conflicts
that were resolvable, that commit deferred content merging by first
updating the index with the unmerged entries and then moving the actual
merging (along with the skip-the-content-update check) to another function
that ran later in the merge process. As part moving the content merging
code, a bug was introduced such that although the message about skipping
the update would be printed (whenever GIT_MERGE_VERBOSITY was sufficiently
high), the file would be unconditionally updated in the working copy
anyway.
When we detect that the file does not need to be updated in the working
copy, update the index appropriately and then return early before updating
the working copy.
Note that there was a similar change in b2c8c0a (merge-recursive: When we
detect we can skip an update, actually skip it 2011-02-28), but it was
reverted by 6db4105 (Revert "Merge branch 'en/merge-recursive'"
2011-05-19) since it did not fix both of the relevant types of unnecessary
update breakages and, worse, it made use of some band-aids that caused
other problems. The reason this change works is due to the changes earlier
in this series to (a) record_df_conflict_files instead of just unlinking
them early, (b) allowing make_room_for_path() to remove D/F entries,
(c) the splitting of update_stages_and_entry() to have its functionality
called at different points, and (d) making the pathnames of the files
involved in the merge available to merge_content().
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-12 05:20:10 +00:00
|
|
|
sha_eq(mfi.sha, a_sha) && mfi.mode == a_mode) {
|
|
|
|
int path_renamed_outside_HEAD;
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 3, _("Skipped %s (merged same as existing)"), path);
|
merge-recursive: When we detect we can skip an update, actually skip it
In 882fd11 (merge-recursive: Delay content merging for renames 2010-09-20),
there was code that checked for whether we could skip updating a file in
the working directory, based on whether the merged version matched the
current working copy. Due to the desire to handle directory/file conflicts
that were resolvable, that commit deferred content merging by first
updating the index with the unmerged entries and then moving the actual
merging (along with the skip-the-content-update check) to another function
that ran later in the merge process. As part moving the content merging
code, a bug was introduced such that although the message about skipping
the update would be printed (whenever GIT_MERGE_VERBOSITY was sufficiently
high), the file would be unconditionally updated in the working copy
anyway.
When we detect that the file does not need to be updated in the working
copy, update the index appropriately and then return early before updating
the working copy.
Note that there was a similar change in b2c8c0a (merge-recursive: When we
detect we can skip an update, actually skip it 2011-02-28), but it was
reverted by 6db4105 (Revert "Merge branch 'en/merge-recursive'"
2011-05-19) since it did not fix both of the relevant types of unnecessary
update breakages and, worse, it made use of some band-aids that caused
other problems. The reason this change works is due to the changes earlier
in this series to (a) record_df_conflict_files instead of just unlinking
them early, (b) allowing make_room_for_path() to remove D/F entries,
(c) the splitting of update_stages_and_entry() to have its functionality
called at different points, and (d) making the pathnames of the files
involved in the merge available to merge_content().
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-12 05:20:10 +00:00
|
|
|
/*
|
|
|
|
* The content merge resulted in the same file contents we
|
|
|
|
* already had. We can return early if those file contents
|
|
|
|
* are recorded at the correct path (which may not be true
|
|
|
|
* if the merge involves a rename).
|
|
|
|
*/
|
|
|
|
path_renamed_outside_HEAD = !path2 || !strcmp(path, path2);
|
|
|
|
if (!path_renamed_outside_HEAD) {
|
|
|
|
add_cacheinfo(mfi.mode, mfi.sha, path,
|
2011-09-23 22:21:01 +00:00
|
|
|
0, (!o->call_depth), 0);
|
merge-recursive: When we detect we can skip an update, actually skip it
In 882fd11 (merge-recursive: Delay content merging for renames 2010-09-20),
there was code that checked for whether we could skip updating a file in
the working directory, based on whether the merged version matched the
current working copy. Due to the desire to handle directory/file conflicts
that were resolvable, that commit deferred content merging by first
updating the index with the unmerged entries and then moving the actual
merging (along with the skip-the-content-update check) to another function
that ran later in the merge process. As part moving the content merging
code, a bug was introduced such that although the message about skipping
the update would be printed (whenever GIT_MERGE_VERBOSITY was sufficiently
high), the file would be unconditionally updated in the working copy
anyway.
When we detect that the file does not need to be updated in the working
copy, update the index appropriately and then return early before updating
the working copy.
Note that there was a similar change in b2c8c0a (merge-recursive: When we
detect we can skip an update, actually skip it 2011-02-28), but it was
reverted by 6db4105 (Revert "Merge branch 'en/merge-recursive'"
2011-05-19) since it did not fix both of the relevant types of unnecessary
update breakages and, worse, it made use of some band-aids that caused
other problems. The reason this change works is due to the changes earlier
in this series to (a) record_df_conflict_files instead of just unlinking
them early, (b) allowing make_room_for_path() to remove D/F entries,
(c) the splitting of update_stages_and_entry() to have its functionality
called at different points, and (d) making the pathnames of the files
involved in the merge available to merge_content().
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-12 05:20:10 +00:00
|
|
|
return mfi.clean;
|
|
|
|
}
|
|
|
|
} else
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 2, _("Auto-merging %s"), path);
|
2010-09-20 08:28:52 +00:00
|
|
|
|
|
|
|
if (!mfi.clean) {
|
|
|
|
if (S_ISGITLINK(mfi.mode))
|
2012-07-25 14:53:13 +00:00
|
|
|
reason = _("submodule");
|
|
|
|
output(o, 1, _("CONFLICT (%s): Merge conflict in %s"),
|
2010-09-20 08:28:52 +00:00
|
|
|
reason, path);
|
2011-08-12 05:20:08 +00:00
|
|
|
if (rename_conflict_info && !df_conflict_remains)
|
2011-08-12 05:20:02 +00:00
|
|
|
update_stages(path, &one, &a, &b);
|
2010-09-20 08:28:52 +00:00
|
|
|
}
|
|
|
|
|
2010-09-20 08:29:07 +00:00
|
|
|
if (df_conflict_remains) {
|
2011-08-12 05:19:53 +00:00
|
|
|
char *new_path;
|
2011-08-12 05:20:06 +00:00
|
|
|
if (o->call_depth) {
|
|
|
|
remove_file_from_cache(path);
|
|
|
|
} else {
|
|
|
|
if (!mfi.clean)
|
|
|
|
update_stages(path, &one, &a, &b);
|
|
|
|
else {
|
|
|
|
int file_from_stage2 = was_tracked(path);
|
|
|
|
struct diff_filespec merged;
|
|
|
|
hashcpy(merged.sha1, mfi.sha);
|
|
|
|
merged.mode = mfi.mode;
|
|
|
|
|
|
|
|
update_stages(path, NULL,
|
|
|
|
file_from_stage2 ? &merged : NULL,
|
|
|
|
file_from_stage2 ? NULL : &merged);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2011-08-12 05:20:08 +00:00
|
|
|
new_path = unique_path(o, path, rename_conflict_info->branch1);
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 1, _("Adding as %s instead"), new_path);
|
2011-08-12 05:20:06 +00:00
|
|
|
update_file(o, 0, mfi.sha, mfi.mode, new_path);
|
2011-08-12 05:19:53 +00:00
|
|
|
free(new_path);
|
2011-08-12 05:20:06 +00:00
|
|
|
mfi.clean = 0;
|
2010-09-20 08:29:07 +00:00
|
|
|
} else {
|
|
|
|
update_file(o, mfi.clean, mfi.sha, mfi.mode, path);
|
|
|
|
}
|
2010-09-20 08:28:52 +00:00
|
|
|
return mfi.clean;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2008-08-12 16:45:14 +00:00
|
|
|
/* Per entry merge function */
|
2008-08-25 14:25:57 +00:00
|
|
|
static int process_entry(struct merge_options *o,
|
|
|
|
const char *path, struct stage_data *entry)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
printf("processing entry, clean cache: %s\n", index_only ? "yes": "no");
|
|
|
|
print_index_entry("\tpath: ", entry);
|
|
|
|
*/
|
|
|
|
int clean_merge = 1;
|
2010-08-05 11:15:32 +00:00
|
|
|
int normalize = o->renormalize;
|
2008-08-12 16:45:14 +00:00
|
|
|
unsigned o_mode = entry->stages[1].mode;
|
|
|
|
unsigned a_mode = entry->stages[2].mode;
|
|
|
|
unsigned b_mode = entry->stages[3].mode;
|
|
|
|
unsigned char *o_sha = stage_sha(entry->stages[1].sha, o_mode);
|
|
|
|
unsigned char *a_sha = stage_sha(entry->stages[2].sha, a_mode);
|
|
|
|
unsigned char *b_sha = stage_sha(entry->stages[3].sha, b_mode);
|
|
|
|
|
2010-07-09 13:10:53 +00:00
|
|
|
entry->processed = 1;
|
2011-08-12 05:20:08 +00:00
|
|
|
if (entry->rename_conflict_info) {
|
|
|
|
struct rename_conflict_info *conflict_info = entry->rename_conflict_info;
|
2010-09-20 08:29:00 +00:00
|
|
|
switch (conflict_info->rename_type) {
|
2010-09-20 08:29:03 +00:00
|
|
|
case RENAME_NORMAL:
|
2011-08-12 05:20:08 +00:00
|
|
|
case RENAME_ONE_FILE_TO_ONE:
|
2010-09-20 08:29:03 +00:00
|
|
|
clean_merge = merge_content(o, path,
|
|
|
|
o_sha, o_mode, a_sha, a_mode, b_sha, b_mode,
|
2011-08-12 05:20:08 +00:00
|
|
|
conflict_info);
|
2010-09-20 08:29:03 +00:00
|
|
|
break;
|
2010-09-20 08:29:02 +00:00
|
|
|
case RENAME_DELETE:
|
|
|
|
clean_merge = 0;
|
|
|
|
conflict_rename_delete(o, conflict_info->pair1,
|
|
|
|
conflict_info->branch1,
|
|
|
|
conflict_info->branch2);
|
|
|
|
break;
|
2010-09-20 08:29:00 +00:00
|
|
|
case RENAME_ONE_FILE_TO_TWO:
|
|
|
|
clean_merge = 0;
|
2011-08-12 05:20:14 +00:00
|
|
|
conflict_rename_rename_1to2(o, conflict_info);
|
2010-09-20 08:29:00 +00:00
|
|
|
break;
|
2011-08-12 05:20:15 +00:00
|
|
|
case RENAME_TWO_FILES_TO_ONE:
|
|
|
|
clean_merge = 0;
|
|
|
|
conflict_rename_rename_2to1(o, conflict_info);
|
2010-09-20 08:29:00 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
entry->processed = 0;
|
|
|
|
break;
|
|
|
|
}
|
2010-09-20 08:29:04 +00:00
|
|
|
} else if (o_sha && (!a_sha || !b_sha)) {
|
2011-08-12 05:20:07 +00:00
|
|
|
/* Case A: Deleted in one */
|
|
|
|
if ((!a_sha && !b_sha) ||
|
|
|
|
(!b_sha && blob_unchanged(o_sha, a_sha, normalize, path)) ||
|
|
|
|
(!a_sha && blob_unchanged(o_sha, b_sha, normalize, path))) {
|
|
|
|
/* Deleted in both or deleted in one and
|
|
|
|
* unchanged in the other */
|
|
|
|
if (a_sha)
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 2, _("Removing %s"), path);
|
2011-08-12 05:20:07 +00:00
|
|
|
/* do not touch working file if it did not exist */
|
|
|
|
remove_file(o, 1, path, !a_sha);
|
|
|
|
} else {
|
|
|
|
/* Modify/delete; deleted side may have put a directory in the way */
|
|
|
|
clean_merge = 0;
|
2011-08-12 05:20:19 +00:00
|
|
|
handle_modify_delete(o, path, o_sha, o_mode,
|
2011-08-12 05:20:07 +00:00
|
|
|
a_sha, a_mode, b_sha, b_mode);
|
2011-08-12 05:19:53 +00:00
|
|
|
}
|
2011-08-12 05:20:07 +00:00
|
|
|
} else if ((!o_sha && a_sha && !b_sha) ||
|
|
|
|
(!o_sha && !a_sha && b_sha)) {
|
|
|
|
/* Case B: Added in one. */
|
|
|
|
/* [nothing|directory] -> ([nothing|directory], file) */
|
|
|
|
|
2010-09-20 08:28:56 +00:00
|
|
|
const char *add_branch;
|
|
|
|
const char *other_branch;
|
|
|
|
unsigned mode;
|
|
|
|
const unsigned char *sha;
|
|
|
|
const char *conf;
|
2010-07-09 13:10:53 +00:00
|
|
|
|
2010-09-20 08:28:56 +00:00
|
|
|
if (a_sha) {
|
|
|
|
add_branch = o->branch1;
|
|
|
|
other_branch = o->branch2;
|
|
|
|
mode = a_mode;
|
|
|
|
sha = a_sha;
|
2012-07-25 14:53:13 +00:00
|
|
|
conf = _("file/directory");
|
2010-09-20 08:28:56 +00:00
|
|
|
} else {
|
|
|
|
add_branch = o->branch2;
|
|
|
|
other_branch = o->branch1;
|
|
|
|
mode = b_mode;
|
|
|
|
sha = b_sha;
|
2012-07-25 14:53:13 +00:00
|
|
|
conf = _("directory/file");
|
2010-09-20 08:28:56 +00:00
|
|
|
}
|
2011-08-12 05:19:57 +00:00
|
|
|
if (dir_in_way(path, !o->call_depth)) {
|
2011-08-12 05:19:53 +00:00
|
|
|
char *new_path = unique_path(o, path, add_branch);
|
2010-09-20 08:28:56 +00:00
|
|
|
clean_merge = 0;
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 1, _("CONFLICT (%s): There is a directory with name %s in %s. "
|
|
|
|
"Adding %s as %s"),
|
2010-09-20 08:28:56 +00:00
|
|
|
conf, path, other_branch, path, new_path);
|
2011-08-12 05:20:06 +00:00
|
|
|
if (o->call_depth)
|
|
|
|
remove_file_from_cache(path);
|
2010-09-20 08:28:56 +00:00
|
|
|
update_file(o, 0, sha, mode, new_path);
|
2011-08-12 05:19:55 +00:00
|
|
|
if (o->call_depth)
|
|
|
|
remove_file_from_cache(path);
|
2011-08-12 05:19:53 +00:00
|
|
|
free(new_path);
|
2010-09-20 08:28:56 +00:00
|
|
|
} else {
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 2, _("Adding %s"), path);
|
2011-08-12 05:20:27 +00:00
|
|
|
/* do not overwrite file if already present */
|
|
|
|
update_file_flags(o, sha, mode, path, 1, !a_sha);
|
2010-09-20 08:28:56 +00:00
|
|
|
}
|
2011-08-12 05:20:07 +00:00
|
|
|
} else if (a_sha && b_sha) {
|
|
|
|
/* Case C: Added in both (check for same permissions) and */
|
|
|
|
/* case D: Modified in both, but differently. */
|
2011-08-12 05:20:08 +00:00
|
|
|
clean_merge = merge_content(o, path,
|
2011-08-12 05:20:07 +00:00
|
|
|
o_sha, o_mode, a_sha, a_mode, b_sha, b_mode,
|
|
|
|
NULL);
|
|
|
|
} else if (!o_sha && !a_sha && !b_sha) {
|
|
|
|
/*
|
|
|
|
* this entry was deleted altogether. a_mode == 0 means
|
|
|
|
* we had that path and want to actively remove it.
|
|
|
|
*/
|
|
|
|
remove_file(o, 1, path, !a_mode);
|
|
|
|
} else
|
2012-07-25 14:53:13 +00:00
|
|
|
die(_("Fatal merge failure, shouldn't happen."));
|
2010-07-09 13:10:53 +00:00
|
|
|
|
|
|
|
return clean_merge;
|
|
|
|
}
|
|
|
|
|
2008-08-25 14:25:57 +00:00
|
|
|
int merge_trees(struct merge_options *o,
|
|
|
|
struct tree *head,
|
2008-08-12 16:45:14 +00:00
|
|
|
struct tree *merge,
|
|
|
|
struct tree *common,
|
|
|
|
struct tree **result)
|
|
|
|
{
|
|
|
|
int code, clean;
|
|
|
|
|
2008-07-01 05:18:57 +00:00
|
|
|
if (o->subtree_shift) {
|
|
|
|
merge = shift_tree_object(head, merge, o->subtree_shift);
|
|
|
|
common = shift_tree_object(head, common, o->subtree_shift);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (sha_eq(common->object.sha1, merge->object.sha1)) {
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 0, _("Already up-to-date!"));
|
2008-08-12 16:45:14 +00:00
|
|
|
*result = head;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-09-02 21:53:47 +00:00
|
|
|
code = git_merge_trees(o->call_depth, common, head, merge);
|
2008-08-12 16:45:14 +00:00
|
|
|
|
merge-recursive: give less scary messages when merge did not start
When unpack_trees() three-way merge logic is called from merge-recursive
and finds that local changes are going to be clobbered, its plumbing level
messages were given as errors first, and then the merge driver added even
more scary message "fatal: merging of trees <a long object name> and
<another long object name> failed".
This is most often encountered by new CVS/SVN migrants who are used to
start a merge from a dirty work tree. The saddest part is that the merge
refused to run to prevent _any_ damage from being done to your work tree
when these messages are given, but the messages look a lot more scarier
than the conflicted case where the user needs to resolve them.
Replace the plumbing level messages so that they talk about what it is
protecting the user from, and end the messages with "Aborting." so that it
becomes clear that the command did not do any harm.
The final "merging of trees failed" message is superfluous, unless you are
interested in debugging the merge-recursive itself. Squelch the current
die() message by default, but allow it to help people who debug git with
verbosity level 4 or greater.
Unless there is some bug, an inner merge that does not touch working tree
should not trigger any such error, so emit the current die() message when
we see an error return from it while running the inner merge, too. It
would also help people who debug git.
We could later add instructions on how to recover (i.e. "stash changes
away or commit on a side branch and retry") instead of the silent
exit(128) I have in this patch, and then use Peff's advice.* mechanism to
squelch it (e.g. "advice.mergeindirtytree"), but they are separate topics.
Tested-by: Nanako Shiraishi <nanako3@lavabit.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-08 05:43:11 +00:00
|
|
|
if (code != 0) {
|
|
|
|
if (show(o, 4) || o->call_depth)
|
2012-07-25 14:53:13 +00:00
|
|
|
die(_("merging of trees %s and %s failed"),
|
merge-recursive: give less scary messages when merge did not start
When unpack_trees() three-way merge logic is called from merge-recursive
and finds that local changes are going to be clobbered, its plumbing level
messages were given as errors first, and then the merge driver added even
more scary message "fatal: merging of trees <a long object name> and
<another long object name> failed".
This is most often encountered by new CVS/SVN migrants who are used to
start a merge from a dirty work tree. The saddest part is that the merge
refused to run to prevent _any_ damage from being done to your work tree
when these messages are given, but the messages look a lot more scarier
than the conflicted case where the user needs to resolve them.
Replace the plumbing level messages so that they talk about what it is
protecting the user from, and end the messages with "Aborting." so that it
becomes clear that the command did not do any harm.
The final "merging of trees failed" message is superfluous, unless you are
interested in debugging the merge-recursive itself. Squelch the current
die() message by default, but allow it to help people who debug git with
verbosity level 4 or greater.
Unless there is some bug, an inner merge that does not touch working tree
should not trigger any such error, so emit the current die() message when
we see an error return from it while running the inner merge, too. It
would also help people who debug git.
We could later add instructions on how to recover (i.e. "stash changes
away or commit on a side branch and retry") instead of the silent
exit(128) I have in this patch, and then use Peff's advice.* mechanism to
squelch it (e.g. "advice.mergeindirtytree"), but they are separate topics.
Tested-by: Nanako Shiraishi <nanako3@lavabit.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-09-08 05:43:11 +00:00
|
|
|
sha1_to_hex(head->object.sha1),
|
|
|
|
sha1_to_hex(merge->object.sha1));
|
|
|
|
else
|
|
|
|
exit(128);
|
|
|
|
}
|
2008-08-12 16:45:14 +00:00
|
|
|
|
|
|
|
if (unmerged_cache()) {
|
|
|
|
struct string_list *entries, *re_head, *re_merge;
|
|
|
|
int i;
|
2008-09-03 17:08:56 +00:00
|
|
|
string_list_clear(&o->current_file_set, 1);
|
|
|
|
string_list_clear(&o->current_directory_set, 1);
|
|
|
|
get_files_dirs(o, head);
|
|
|
|
get_files_dirs(o, merge);
|
2008-08-12 16:45:14 +00:00
|
|
|
|
|
|
|
entries = get_unmerged();
|
2011-08-12 05:19:58 +00:00
|
|
|
record_df_conflict_files(o, entries);
|
2008-08-25 14:25:57 +00:00
|
|
|
re_head = get_renames(o, head, common, head, merge, entries);
|
|
|
|
re_merge = get_renames(o, merge, common, head, merge, entries);
|
|
|
|
clean = process_renames(o, re_head, re_merge);
|
2011-08-12 05:20:07 +00:00
|
|
|
for (i = entries->nr-1; 0 <= i; i--) {
|
2008-08-12 16:45:14 +00:00
|
|
|
const char *path = entries->items[i].string;
|
|
|
|
struct stage_data *e = entries->items[i].util;
|
|
|
|
if (!e->processed
|
2008-08-25 14:25:57 +00:00
|
|
|
&& !process_entry(o, path, e))
|
2008-08-12 16:45:14 +00:00
|
|
|
clean = 0;
|
|
|
|
}
|
2010-09-20 08:28:35 +00:00
|
|
|
for (i = 0; i < entries->nr; i++) {
|
|
|
|
struct stage_data *e = entries->items[i].util;
|
|
|
|
if (!e->processed)
|
2012-07-25 14:53:13 +00:00
|
|
|
die(_("Unprocessed path??? %s"),
|
2010-09-20 08:28:35 +00:00
|
|
|
entries->items[i].string);
|
|
|
|
}
|
2008-08-12 16:45:14 +00:00
|
|
|
|
|
|
|
string_list_clear(re_merge, 0);
|
|
|
|
string_list_clear(re_head, 0);
|
|
|
|
string_list_clear(entries, 1);
|
|
|
|
|
|
|
|
}
|
|
|
|
else
|
|
|
|
clean = 1;
|
|
|
|
|
2008-09-02 21:53:47 +00:00
|
|
|
if (o->call_depth)
|
2008-08-25 14:25:57 +00:00
|
|
|
*result = write_tree_from_memory(o);
|
2008-08-12 16:45:14 +00:00
|
|
|
|
|
|
|
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 cleanness of the merge.
|
|
|
|
*/
|
2008-08-25 14:25:57 +00:00
|
|
|
int merge_recursive(struct merge_options *o,
|
|
|
|
struct commit *h1,
|
2008-08-12 16:45:14 +00:00
|
|
|
struct commit *h2,
|
|
|
|
struct commit_list *ca,
|
|
|
|
struct commit **result)
|
|
|
|
{
|
|
|
|
struct commit_list *iter;
|
|
|
|
struct commit *merged_common_ancestors;
|
|
|
|
struct tree *mrtree = mrtree;
|
|
|
|
int clean;
|
|
|
|
|
2008-08-25 14:25:57 +00:00
|
|
|
if (show(o, 4)) {
|
2012-07-25 14:53:13 +00:00
|
|
|
output(o, 4, _("Merging:"));
|
2008-09-02 21:30:09 +00:00
|
|
|
output_commit_title(o, h1);
|
|
|
|
output_commit_title(o, h2);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!ca) {
|
|
|
|
ca = get_merge_bases(h1, h2, 1);
|
|
|
|
ca = reverse_commit_list(ca);
|
|
|
|
}
|
|
|
|
|
2008-08-25 14:25:57 +00:00
|
|
|
if (show(o, 5)) {
|
2012-08-05 17:56:38 +00:00
|
|
|
unsigned cnt = commit_list_count(ca);
|
|
|
|
|
|
|
|
output(o, 5, Q_("found %u common ancestor:",
|
|
|
|
"found %u common ancestors:", cnt), cnt);
|
2008-08-12 16:45:14 +00:00
|
|
|
for (iter = ca; iter; iter = iter->next)
|
2008-09-02 21:30:09 +00:00
|
|
|
output_commit_title(o, iter->item);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
merged_common_ancestors = pop_commit(&ca);
|
|
|
|
if (merged_common_ancestors == NULL) {
|
2011-08-16 18:27:39 +00:00
|
|
|
/* if there is no common ancestor, use an empty tree */
|
|
|
|
struct tree *tree;
|
2008-08-12 16:45:14 +00:00
|
|
|
|
2012-03-22 18:53:24 +00:00
|
|
|
tree = lookup_tree(EMPTY_TREE_SHA1_BIN);
|
2008-08-12 16:45:14 +00:00
|
|
|
merged_common_ancestors = make_virtual_commit(tree, "ancestor");
|
|
|
|
}
|
|
|
|
|
|
|
|
for (iter = ca; iter; iter = iter->next) {
|
2008-08-25 14:25:57 +00:00
|
|
|
const char *saved_b1, *saved_b2;
|
2008-09-02 21:30:09 +00:00
|
|
|
o->call_depth++;
|
2008-08-12 16:45:14 +00:00
|
|
|
/*
|
|
|
|
* When the merge fails, the result contains files
|
|
|
|
* with conflict markers. The cleanness flag is
|
|
|
|
* ignored, it was never actually used, as result of
|
|
|
|
* merge_trees has always overwritten it: the committed
|
|
|
|
* "conflicts" were already resolved.
|
|
|
|
*/
|
|
|
|
discard_cache();
|
2008-08-25 14:25:57 +00:00
|
|
|
saved_b1 = o->branch1;
|
|
|
|
saved_b2 = o->branch2;
|
|
|
|
o->branch1 = "Temporary merge branch 1";
|
|
|
|
o->branch2 = "Temporary merge branch 2";
|
|
|
|
merge_recursive(o, merged_common_ancestors, iter->item,
|
|
|
|
NULL, &merged_common_ancestors);
|
|
|
|
o->branch1 = saved_b1;
|
|
|
|
o->branch2 = saved_b2;
|
2008-09-02 21:30:09 +00:00
|
|
|
o->call_depth--;
|
2008-08-12 16:45:14 +00:00
|
|
|
|
|
|
|
if (!merged_common_ancestors)
|
2012-07-25 14:53:13 +00:00
|
|
|
die(_("merge returned no commit"));
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
discard_cache();
|
2008-09-02 21:53:47 +00:00
|
|
|
if (!o->call_depth)
|
2008-08-12 16:45:14 +00:00
|
|
|
read_cache();
|
|
|
|
|
2010-03-21 00:52:21 +00:00
|
|
|
o->ancestor = "merged common ancestors";
|
2008-08-25 14:25:57 +00:00
|
|
|
clean = merge_trees(o, h1->tree, h2->tree, merged_common_ancestors->tree,
|
|
|
|
&mrtree);
|
2008-08-12 16:45:14 +00:00
|
|
|
|
2008-09-02 21:53:47 +00:00
|
|
|
if (o->call_depth) {
|
2008-08-12 16:45:14 +00:00
|
|
|
*result = make_virtual_commit(mrtree, "merged tree");
|
|
|
|
commit_list_insert(h1, &(*result)->parents);
|
|
|
|
commit_list_insert(h2, &(*result)->parents->next);
|
|
|
|
}
|
2008-09-03 00:30:03 +00:00
|
|
|
flush_output(o);
|
2011-01-06 21:50:06 +00:00
|
|
|
if (show(o, 2))
|
|
|
|
diff_warn_rename_limit("merge.renamelimit",
|
|
|
|
o->needed_rename_limit, 0);
|
2008-08-12 16:45:14 +00:00
|
|
|
return clean;
|
|
|
|
}
|
|
|
|
|
2008-08-12 20:13:59 +00:00
|
|
|
static struct commit *get_ref(const unsigned char *sha1, const char *name)
|
|
|
|
{
|
|
|
|
struct object *object;
|
|
|
|
|
|
|
|
object = deref_tag(parse_object(sha1), name, strlen(name));
|
|
|
|
if (!object)
|
|
|
|
return NULL;
|
|
|
|
if (object->type == OBJ_TREE)
|
|
|
|
return make_virtual_commit((struct tree*)object, name);
|
|
|
|
if (object->type != OBJ_COMMIT)
|
|
|
|
return NULL;
|
|
|
|
if (parse_commit((struct commit *)object))
|
|
|
|
return NULL;
|
|
|
|
return (struct commit *)object;
|
|
|
|
}
|
|
|
|
|
2008-08-25 14:25:57 +00:00
|
|
|
int merge_recursive_generic(struct merge_options *o,
|
|
|
|
const unsigned char *head,
|
|
|
|
const unsigned char *merge,
|
|
|
|
int num_base_list,
|
|
|
|
const unsigned char **base_list,
|
|
|
|
struct commit **result)
|
2008-08-12 20:13:59 +00:00
|
|
|
{
|
2014-06-13 12:19:23 +00:00
|
|
|
int clean;
|
2008-08-12 20:13:59 +00:00
|
|
|
struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
|
2008-08-25 14:25:57 +00:00
|
|
|
struct commit *head_commit = get_ref(head, o->branch1);
|
|
|
|
struct commit *next_commit = get_ref(merge, o->branch2);
|
2008-08-12 20:13:59 +00:00
|
|
|
struct commit_list *ca = NULL;
|
|
|
|
|
|
|
|
if (base_list) {
|
|
|
|
int i;
|
2008-08-25 14:25:57 +00:00
|
|
|
for (i = 0; i < num_base_list; ++i) {
|
2008-08-12 20:13:59 +00:00
|
|
|
struct commit *base;
|
2008-08-25 14:25:57 +00:00
|
|
|
if (!(base = get_ref(base_list[i], sha1_to_hex(base_list[i]))))
|
2012-07-25 14:53:13 +00:00
|
|
|
return error(_("Could not parse object '%s'"),
|
2008-08-25 14:25:57 +00:00
|
|
|
sha1_to_hex(base_list[i]));
|
2008-08-12 20:13:59 +00:00
|
|
|
commit_list_insert(base, &ca);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-13 12:19:23 +00:00
|
|
|
hold_locked_index(lock, 1);
|
2008-08-25 14:25:57 +00:00
|
|
|
clean = merge_recursive(o, head_commit, next_commit, ca,
|
|
|
|
result);
|
2008-08-12 20:13:59 +00:00
|
|
|
if (active_cache_changed &&
|
2014-06-13 12:19:23 +00:00
|
|
|
write_locked_index(&the_index, lock, COMMIT_LOCK))
|
2012-07-25 14:53:13 +00:00
|
|
|
return error(_("Unable to write index."));
|
2008-08-12 20:13:59 +00:00
|
|
|
|
|
|
|
return clean ? 0 : 1;
|
|
|
|
}
|
|
|
|
|
2008-08-25 14:25:57 +00:00
|
|
|
static int merge_recursive_config(const char *var, const char *value, void *cb)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
2008-08-25 14:25:57 +00:00
|
|
|
struct merge_options *o = cb;
|
2011-05-14 20:19:21 +00:00
|
|
|
if (!strcmp(var, "merge.verbosity")) {
|
2008-08-25 14:25:57 +00:00
|
|
|
o->verbosity = git_config_int(var, value);
|
2008-08-12 16:45:14 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2011-05-14 20:19:21 +00:00
|
|
|
if (!strcmp(var, "diff.renamelimit")) {
|
2008-08-25 14:25:57 +00:00
|
|
|
o->diff_rename_limit = git_config_int(var, value);
|
2008-08-12 16:45:14 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2011-05-14 20:19:21 +00:00
|
|
|
if (!strcmp(var, "merge.renamelimit")) {
|
2008-08-25 14:25:57 +00:00
|
|
|
o->merge_rename_limit = git_config_int(var, value);
|
2008-08-12 16:45:14 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-10-19 00:40:50 +00:00
|
|
|
return git_xmerge_config(var, value, cb);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
|
|
|
|
2008-08-25 14:25:57 +00:00
|
|
|
void init_merge_options(struct merge_options *o)
|
2008-08-12 16:45:14 +00:00
|
|
|
{
|
2008-08-25 14:25:57 +00:00
|
|
|
memset(o, 0, sizeof(struct merge_options));
|
|
|
|
o->verbosity = 2;
|
|
|
|
o->buffer_output = 1;
|
|
|
|
o->diff_rename_limit = -1;
|
|
|
|
o->merge_rename_limit = -1;
|
2010-08-05 11:32:41 +00:00
|
|
|
o->renormalize = 0;
|
2008-08-25 14:25:57 +00:00
|
|
|
git_config(merge_recursive_config, o);
|
2008-08-12 16:45:14 +00:00
|
|
|
if (getenv("GIT_MERGE_VERBOSITY"))
|
2008-08-25 14:25:57 +00:00
|
|
|
o->verbosity =
|
2008-08-12 16:45:14 +00:00
|
|
|
strtol(getenv("GIT_MERGE_VERBOSITY"), NULL, 10);
|
2008-08-25 14:25:57 +00:00
|
|
|
if (o->verbosity >= 5)
|
|
|
|
o->buffer_output = 0;
|
2008-09-03 00:30:03 +00:00
|
|
|
strbuf_init(&o->obuf, 0);
|
2014-07-18 09:19:00 +00:00
|
|
|
string_list_init(&o->current_file_set, 1);
|
|
|
|
string_list_init(&o->current_directory_set, 1);
|
|
|
|
string_list_init(&o->df_conflict_file_set, 1);
|
2008-08-12 16:45:14 +00:00
|
|
|
}
|
2010-08-26 05:47:58 +00:00
|
|
|
|
|
|
|
int parse_merge_opt(struct merge_options *o, const char *s)
|
|
|
|
{
|
2014-06-18 19:48:29 +00:00
|
|
|
const char *arg;
|
|
|
|
|
2010-08-26 05:47:58 +00:00
|
|
|
if (!s || !*s)
|
|
|
|
return -1;
|
|
|
|
if (!strcmp(s, "ours"))
|
|
|
|
o->recursive_variant = MERGE_RECURSIVE_OURS;
|
|
|
|
else if (!strcmp(s, "theirs"))
|
|
|
|
o->recursive_variant = MERGE_RECURSIVE_THEIRS;
|
|
|
|
else if (!strcmp(s, "subtree"))
|
|
|
|
o->subtree_shift = "";
|
2014-06-18 19:48:29 +00:00
|
|
|
else if (skip_prefix(s, "subtree=", &arg))
|
|
|
|
o->subtree_shift = arg;
|
2010-08-26 05:50:45 +00:00
|
|
|
else if (!strcmp(s, "patience"))
|
2012-02-19 23:36:55 +00:00
|
|
|
o->xdl_opts = DIFF_WITH_ALG(o, PATIENCE_DIFF);
|
2011-07-12 06:10:25 +00:00
|
|
|
else if (!strcmp(s, "histogram"))
|
2012-02-19 23:36:55 +00:00
|
|
|
o->xdl_opts = DIFF_WITH_ALG(o, HISTOGRAM_DIFF);
|
2014-06-18 19:48:29 +00:00
|
|
|
else if (skip_prefix(s, "diff-algorithm=", &arg)) {
|
|
|
|
long value = parse_algorithm_value(arg);
|
2013-01-16 07:51:58 +00:00
|
|
|
if (value < 0)
|
|
|
|
return -1;
|
|
|
|
/* clear out previous settings */
|
|
|
|
DIFF_XDL_CLR(o, NEED_MINIMAL);
|
|
|
|
o->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;
|
|
|
|
o->xdl_opts |= value;
|
|
|
|
}
|
2010-08-26 05:51:47 +00:00
|
|
|
else if (!strcmp(s, "ignore-space-change"))
|
|
|
|
o->xdl_opts |= XDF_IGNORE_WHITESPACE_CHANGE;
|
|
|
|
else if (!strcmp(s, "ignore-all-space"))
|
|
|
|
o->xdl_opts |= XDF_IGNORE_WHITESPACE;
|
|
|
|
else if (!strcmp(s, "ignore-space-at-eol"))
|
|
|
|
o->xdl_opts |= XDF_IGNORE_WHITESPACE_AT_EOL;
|
2010-08-26 05:47:58 +00:00
|
|
|
else if (!strcmp(s, "renormalize"))
|
|
|
|
o->renormalize = 1;
|
|
|
|
else if (!strcmp(s, "no-renormalize"))
|
|
|
|
o->renormalize = 0;
|
2014-06-18 19:48:29 +00:00
|
|
|
else if (skip_prefix(s, "rename-threshold=", &arg)) {
|
|
|
|
if ((o->rename_score = parse_rename_score(&arg)) == -1 || *arg != 0)
|
2010-09-27 23:58:25 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2010-08-26 05:47:58 +00:00
|
|
|
else
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|