2008-03-06 20:26:14 +00:00
|
|
|
#define NO_THE_INDEX_COMPATIBILITY_MACROS
|
2006-07-30 18:25:18 +00:00
|
|
|
#include "cache.h"
|
2006-12-05 00:00:46 +00:00
|
|
|
#include "dir.h"
|
2006-07-30 18:25:18 +00:00
|
|
|
#include "tree.h"
|
|
|
|
#include "tree-walk.h"
|
2006-07-30 18:26:15 +00:00
|
|
|
#include "cache-tree.h"
|
2006-07-30 18:25:18 +00:00
|
|
|
#include "unpack-trees.h"
|
2007-04-18 18:27:45 +00:00
|
|
|
#include "progress.h"
|
2007-07-17 18:28:28 +00:00
|
|
|
#include "refs.h"
|
2006-07-30 18:25:18 +00:00
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
static void add_entry(struct unpack_trees_options *o, struct cache_entry *ce,
|
|
|
|
unsigned int set, unsigned int clear)
|
2007-08-10 19:15:54 +00:00
|
|
|
{
|
2008-03-07 02:12:28 +00:00
|
|
|
unsigned int size = ce_size(ce);
|
|
|
|
struct cache_entry *new = xmalloc(size);
|
|
|
|
|
|
|
|
clear |= CE_HASHED | CE_UNHASHED;
|
|
|
|
|
|
|
|
memcpy(new, ce, size);
|
|
|
|
new->next = NULL;
|
|
|
|
new->ce_flags = (new->ce_flags & ~clear) | set;
|
|
|
|
add_index_entry(&o->result, new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE|ADD_CACHE_SKIP_DFCHECK);
|
2007-08-10 19:15:54 +00:00
|
|
|
}
|
|
|
|
|
2006-07-30 18:25:18 +00:00
|
|
|
/* Unlink the last component and attempt to remove leading
|
|
|
|
* directories, in case this unlink is the removal of the
|
|
|
|
* last entry in the directory -- empty directories are removed.
|
|
|
|
*/
|
2007-05-11 06:44:53 +00:00
|
|
|
static void unlink_entry(char *name, char *last_symlink)
|
2006-07-30 18:25:18 +00:00
|
|
|
{
|
|
|
|
char *cp, *prev;
|
|
|
|
|
2007-05-11 06:44:53 +00:00
|
|
|
if (has_symlink_leading_path(name, last_symlink))
|
|
|
|
return;
|
2006-07-30 18:25:18 +00:00
|
|
|
if (unlink(name))
|
|
|
|
return;
|
|
|
|
prev = NULL;
|
|
|
|
while (1) {
|
|
|
|
int status;
|
|
|
|
cp = strrchr(name, '/');
|
|
|
|
if (prev)
|
|
|
|
*prev = '/';
|
|
|
|
if (!cp)
|
|
|
|
break;
|
|
|
|
|
|
|
|
*cp = 0;
|
|
|
|
status = rmdir(name);
|
|
|
|
if (status) {
|
|
|
|
*cp = '/';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
prev = cp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct checkout state;
|
Discard "deleted" cache entries after using them to update the working tree
Way back in read-tree.c, we used a mode 0 cache entry to indicate that
an entry had been deleted, so that the update code would remove the
working tree file, and we would just skip it when writing out the
index file afterward.
These days, unpack_trees is a library function, and it is still
leaving these entries in the active cache. Furthermore, unpack_trees
doesn't correctly ignore those entries, and who knows what other code
wouldn't expect them to be there, but just isn't yet called after a
call to unpack_trees. To avoid having other code trip over these
entries, have check_updates() remove them after it removes the working
tree files.
While we're at it, simplify the loop in check_updates(), and avoid
passing global variables as parameters to check_updates(): there is
only one call site anyway.
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
2008-02-07 16:39:59 +00:00
|
|
|
static void check_updates(struct unpack_trees_options *o)
|
2006-07-30 18:25:18 +00:00
|
|
|
{
|
2007-04-18 18:27:45 +00:00
|
|
|
unsigned cnt = 0, total = 0;
|
2007-10-30 18:57:32 +00:00
|
|
|
struct progress *progress = NULL;
|
2007-05-11 06:44:53 +00:00
|
|
|
char last_symlink[PATH_MAX];
|
2008-03-07 02:12:28 +00:00
|
|
|
struct index_state *index = &o->result;
|
Discard "deleted" cache entries after using them to update the working tree
Way back in read-tree.c, we used a mode 0 cache entry to indicate that
an entry had been deleted, so that the update code would remove the
working tree file, and we would just skip it when writing out the
index file afterward.
These days, unpack_trees is a library function, and it is still
leaving these entries in the active cache. Furthermore, unpack_trees
doesn't correctly ignore those entries, and who knows what other code
wouldn't expect them to be there, but just isn't yet called after a
call to unpack_trees. To avoid having other code trip over these
entries, have check_updates() remove them after it removes the working
tree files.
While we're at it, simplify the loop in check_updates(), and avoid
passing global variables as parameters to check_updates(): there is
only one call site anyway.
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
2008-02-07 16:39:59 +00:00
|
|
|
int i;
|
2006-07-30 18:25:18 +00:00
|
|
|
|
|
|
|
if (o->update && o->verbose_update) {
|
2008-03-07 02:12:28 +00:00
|
|
|
for (total = cnt = 0; cnt < index->cache_nr; cnt++) {
|
|
|
|
struct cache_entry *ce = index->cache[cnt];
|
2008-01-15 00:03:17 +00:00
|
|
|
if (ce->ce_flags & (CE_UPDATE | CE_REMOVE))
|
2006-07-30 18:25:18 +00:00
|
|
|
total++;
|
|
|
|
}
|
|
|
|
|
2007-10-30 18:57:32 +00:00
|
|
|
progress = start_progress_delay("Checking out files",
|
Be more verbose when checkout takes a long time
So I find it irritating when git thinks for a long time without telling me
what's taking so long. And by "long time" I definitely mean less than two
seconds, which is already way too long for me.
This hits me when doing a large pull and the checkout takes a long time,
or when just switching to another branch that is old and again checkout
takes a while.
Now, git read-tree already had support for the "-v" flag that does nice
updates about what's going on, but it was delayed by two seconds, and if
the thing had already done more than half by then it would be quiet even
after that, so in practice it meant that we migth be quiet for up to four
seconds. Much too long.
So this patch changes the timeout to just one second, which makes it much
more palatable to me.
The other thing this patch does is that "git checkout" now doesn't disable
the "-v" flag when doing its thing, and only disables the output when
given the -q flag. When allowing "checkout -m" to fall back to a 3-way
merge, the users will see the error message from straight "checkout",
so we will tell them that we do fall back to make them look less scary.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-23 21:36:08 +00:00
|
|
|
total, 50, 1);
|
2006-07-30 18:25:18 +00:00
|
|
|
cnt = 0;
|
|
|
|
}
|
|
|
|
|
2007-05-11 06:44:53 +00:00
|
|
|
*last_symlink = '\0';
|
2008-03-07 02:12:28 +00:00
|
|
|
for (i = 0; i < index->cache_nr; i++) {
|
|
|
|
struct cache_entry *ce = index->cache[i];
|
2006-07-30 18:25:18 +00:00
|
|
|
|
2008-01-15 00:03:17 +00:00
|
|
|
if (ce->ce_flags & (CE_UPDATE | CE_REMOVE))
|
2007-10-30 18:57:33 +00:00
|
|
|
display_progress(progress, ++cnt);
|
2008-01-15 00:03:17 +00:00
|
|
|
if (ce->ce_flags & CE_REMOVE) {
|
2006-07-30 18:25:18 +00:00
|
|
|
if (o->update)
|
2007-05-11 06:44:53 +00:00
|
|
|
unlink_entry(ce->name, last_symlink);
|
2008-03-07 02:12:28 +00:00
|
|
|
remove_index_entry_at(&o->result, i);
|
Discard "deleted" cache entries after using them to update the working tree
Way back in read-tree.c, we used a mode 0 cache entry to indicate that
an entry had been deleted, so that the update code would remove the
working tree file, and we would just skip it when writing out the
index file afterward.
These days, unpack_trees is a library function, and it is still
leaving these entries in the active cache. Furthermore, unpack_trees
doesn't correctly ignore those entries, and who knows what other code
wouldn't expect them to be there, but just isn't yet called after a
call to unpack_trees. To avoid having other code trip over these
entries, have check_updates() remove them after it removes the working
tree files.
While we're at it, simplify the loop in check_updates(), and avoid
passing global variables as parameters to check_updates(): there is
only one call site anyway.
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
2008-02-07 16:39:59 +00:00
|
|
|
i--;
|
2006-07-30 18:25:18 +00:00
|
|
|
continue;
|
|
|
|
}
|
2008-01-15 00:03:17 +00:00
|
|
|
if (ce->ce_flags & CE_UPDATE) {
|
|
|
|
ce->ce_flags &= ~CE_UPDATE;
|
2007-05-11 06:44:53 +00:00
|
|
|
if (o->update) {
|
2006-07-30 18:25:18 +00:00
|
|
|
checkout_entry(ce, &state, NULL);
|
2007-05-11 06:44:53 +00:00
|
|
|
*last_symlink = '\0';
|
|
|
|
}
|
2006-07-30 18:25:18 +00:00
|
|
|
}
|
|
|
|
}
|
2007-10-30 18:57:33 +00:00
|
|
|
stop_progress(&progress);
|
2006-07-30 18:25:18 +00:00
|
|
|
}
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
static inline int call_unpack_fn(struct cache_entry **src, struct unpack_trees_options *o)
|
2008-03-06 04:15:44 +00:00
|
|
|
{
|
2008-03-07 02:12:28 +00:00
|
|
|
int ret = o->fn(src, o);
|
|
|
|
if (ret > 0)
|
2008-03-06 04:15:44 +00:00
|
|
|
ret = 0;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unpack_index_entry(struct cache_entry *ce, struct unpack_trees_options *o)
|
|
|
|
{
|
|
|
|
struct cache_entry *src[5] = { ce, };
|
2008-03-07 02:12:28 +00:00
|
|
|
|
|
|
|
o->pos++;
|
2008-03-06 04:15:44 +00:00
|
|
|
if (ce_stage(ce)) {
|
|
|
|
if (o->skip_unmerged) {
|
2008-03-07 02:12:28 +00:00
|
|
|
add_entry(o, ce, 0, 0);
|
|
|
|
return 0;
|
2008-03-06 04:15:44 +00:00
|
|
|
}
|
|
|
|
}
|
2008-03-07 02:12:28 +00:00
|
|
|
return call_unpack_fn(src, o);
|
2008-03-06 04:15:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int traverse_trees_recursive(int n, unsigned long dirmask, unsigned long df_conflicts, struct name_entry *names, struct traverse_info *info)
|
2006-07-30 18:25:18 +00:00
|
|
|
{
|
|
|
|
int i;
|
2008-03-14 05:07:18 +00:00
|
|
|
struct tree_desc t[MAX_UNPACK_TREES];
|
2008-03-06 04:15:44 +00:00
|
|
|
struct traverse_info newinfo;
|
|
|
|
struct name_entry *p;
|
|
|
|
|
|
|
|
p = names;
|
|
|
|
while (!p->mode)
|
|
|
|
p++;
|
|
|
|
|
|
|
|
newinfo = *info;
|
|
|
|
newinfo.prev = info;
|
|
|
|
newinfo.name = *p;
|
|
|
|
newinfo.pathlen += tree_entry_len(p->path, p->sha1) + 1;
|
|
|
|
newinfo.conflicts |= df_conflicts;
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++, dirmask >>= 1) {
|
|
|
|
const unsigned char *sha1 = NULL;
|
|
|
|
if (dirmask & 1)
|
|
|
|
sha1 = names[i].sha1;
|
|
|
|
fill_tree_descriptor(t+i, sha1);
|
|
|
|
}
|
2008-03-10 08:26:23 +00:00
|
|
|
return traverse_trees(n, t, &newinfo);
|
2008-03-06 04:15:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compare the traverse-path to the cache entry without actually
|
|
|
|
* having to generate the textual representation of the traverse
|
|
|
|
* path.
|
|
|
|
*
|
|
|
|
* NOTE! This *only* compares up to the size of the traverse path
|
|
|
|
* itself - the caller needs to do the final check for the cache
|
|
|
|
* entry having more data at the end!
|
|
|
|
*/
|
|
|
|
static int do_compare_entry(const struct cache_entry *ce, const struct traverse_info *info, const struct name_entry *n)
|
|
|
|
{
|
|
|
|
int len, pathlen, ce_len;
|
|
|
|
const char *ce_name;
|
|
|
|
|
|
|
|
if (info->prev) {
|
|
|
|
int cmp = do_compare_entry(ce, info->prev, &info->name);
|
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
}
|
|
|
|
pathlen = info->pathlen;
|
|
|
|
ce_len = ce_namelen(ce);
|
|
|
|
|
|
|
|
/* If ce_len < pathlen then we must have previously hit "name == directory" entry */
|
|
|
|
if (ce_len < pathlen)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
ce_len -= pathlen;
|
|
|
|
ce_name = ce->name + pathlen;
|
|
|
|
|
|
|
|
len = tree_entry_len(n->path, n->sha1);
|
|
|
|
return df_name_compare(ce_name, ce_len, S_IFREG, n->path, len, n->mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int compare_entry(const struct cache_entry *ce, const struct traverse_info *info, const struct name_entry *n)
|
|
|
|
{
|
|
|
|
int cmp = do_compare_entry(ce, info, n);
|
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Even if the beginning compared identically, the ce should
|
|
|
|
* compare as bigger than a directory leading up to it!
|
|
|
|
*/
|
|
|
|
return ce_namelen(ce) > traverse_path_len(info, n);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct cache_entry *create_ce_entry(const struct traverse_info *info, const struct name_entry *n, int stage)
|
|
|
|
{
|
|
|
|
int len = traverse_path_len(info, n);
|
|
|
|
struct cache_entry *ce = xcalloc(1, cache_entry_size(len));
|
|
|
|
|
|
|
|
ce->ce_mode = create_ce_mode(n->mode);
|
|
|
|
ce->ce_flags = create_ce_flags(len, stage);
|
|
|
|
hashcpy(ce->sha1, n->sha1);
|
|
|
|
make_traverse_path(ce->name, info, n);
|
|
|
|
|
|
|
|
return ce;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unpack_nondirectories(int n, unsigned long mask, unsigned long dirmask, struct cache_entry *src[5],
|
2008-03-07 02:12:28 +00:00
|
|
|
const struct name_entry *names, const struct traverse_info *info)
|
2008-03-06 04:15:44 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct unpack_trees_options *o = info->data;
|
|
|
|
unsigned long conflicts;
|
|
|
|
|
|
|
|
/* Do we have *only* directories? Nothing to do */
|
|
|
|
if (mask == dirmask && !src[0])
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
conflicts = info->conflicts;
|
|
|
|
if (o->merge)
|
|
|
|
conflicts >>= 1;
|
|
|
|
conflicts |= dirmask;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ok, we've filled in up to any potential index entry in src[0],
|
|
|
|
* now do the rest.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
int stage;
|
|
|
|
unsigned int bit = 1ul << i;
|
|
|
|
if (conflicts & bit) {
|
|
|
|
src[i + o->merge] = o->df_conflict_entry;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!(mask & bit))
|
|
|
|
continue;
|
|
|
|
if (!o->merge)
|
|
|
|
stage = 0;
|
|
|
|
else if (i + 1 < o->head_idx)
|
|
|
|
stage = 1;
|
|
|
|
else if (i + 1 > o->head_idx)
|
|
|
|
stage = 3;
|
|
|
|
else
|
|
|
|
stage = 2;
|
|
|
|
src[i + o->merge] = create_ce_entry(info, names + i, stage);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (o->merge)
|
2008-03-07 02:12:28 +00:00
|
|
|
return call_unpack_fn(src, o);
|
2008-03-06 04:15:44 +00:00
|
|
|
|
|
|
|
n += o->merge;
|
|
|
|
for (i = 0; i < n; i++)
|
2008-03-07 02:12:28 +00:00
|
|
|
add_entry(o, src[i], 0, 0);
|
2008-03-06 04:15:44 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unpack_callback(int n, unsigned long mask, unsigned long dirmask, struct name_entry *names, struct traverse_info *info)
|
|
|
|
{
|
|
|
|
struct cache_entry *src[5] = { NULL, };
|
|
|
|
struct unpack_trees_options *o = info->data;
|
|
|
|
const struct name_entry *p = names;
|
|
|
|
|
|
|
|
/* Find first entry with a real name (we could use "mask" too) */
|
|
|
|
while (!p->mode)
|
|
|
|
p++;
|
|
|
|
|
|
|
|
/* Are we supposed to look at the index too? */
|
|
|
|
if (o->merge) {
|
2008-03-07 02:12:28 +00:00
|
|
|
while (o->pos < o->src_index->cache_nr) {
|
|
|
|
struct cache_entry *ce = o->src_index->cache[o->pos];
|
2008-03-06 04:15:44 +00:00
|
|
|
int cmp = compare_entry(ce, info, p);
|
|
|
|
if (cmp < 0) {
|
|
|
|
if (unpack_index_entry(ce, o) < 0)
|
|
|
|
return -1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!cmp) {
|
2008-03-07 02:12:28 +00:00
|
|
|
o->pos++;
|
2008-03-06 04:15:44 +00:00
|
|
|
if (ce_stage(ce)) {
|
|
|
|
/*
|
|
|
|
* If we skip unmerged index entries, we'll skip this
|
|
|
|
* entry *and* the tree entries associated with it!
|
|
|
|
*/
|
2008-03-07 02:12:28 +00:00
|
|
|
if (o->skip_unmerged) {
|
|
|
|
add_entry(o, ce, 0, 0);
|
2008-03-06 04:15:44 +00:00
|
|
|
return mask;
|
2008-03-07 02:12:28 +00:00
|
|
|
}
|
2008-03-06 04:15:44 +00:00
|
|
|
}
|
|
|
|
src[0] = ce;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
if (unpack_nondirectories(n, mask, dirmask, src, names, info) < 0)
|
2008-03-06 04:15:44 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* Now handle any directories.. */
|
|
|
|
if (dirmask) {
|
|
|
|
unsigned long conflicts = mask & ~dirmask;
|
|
|
|
if (o->merge) {
|
|
|
|
conflicts <<= 1;
|
|
|
|
if (src[0])
|
|
|
|
conflicts |= 1;
|
|
|
|
}
|
2008-03-10 08:26:23 +00:00
|
|
|
if (traverse_trees_recursive(n, dirmask, conflicts,
|
|
|
|
names, info) < 0)
|
|
|
|
return -1;
|
2008-03-06 04:15:44 +00:00
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unpack_failed(struct unpack_trees_options *o, const char *message)
|
|
|
|
{
|
2008-03-07 21:48:40 +00:00
|
|
|
discard_index(&o->result);
|
2008-03-06 04:15:44 +00:00
|
|
|
if (!o->gently) {
|
|
|
|
if (message)
|
|
|
|
return error(message);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options *o)
|
|
|
|
{
|
2006-12-04 10:11:39 +00:00
|
|
|
static struct cache_entry *dfc;
|
2006-07-30 18:25:18 +00:00
|
|
|
|
2008-03-14 05:07:18 +00:00
|
|
|
if (len > MAX_UNPACK_TREES)
|
|
|
|
die("unpack_trees takes at most %d trees", MAX_UNPACK_TREES);
|
2006-07-30 18:26:15 +00:00
|
|
|
memset(&state, 0, sizeof(state));
|
2006-07-30 18:25:18 +00:00
|
|
|
state.base_dir = "";
|
|
|
|
state.force = 1;
|
|
|
|
state.quiet = 1;
|
|
|
|
state.refresh_cache = 1;
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
memset(&o->result, 0, sizeof(o->result));
|
2006-07-30 18:25:18 +00:00
|
|
|
o->merge_size = len;
|
2006-12-04 10:11:39 +00:00
|
|
|
|
|
|
|
if (!dfc)
|
|
|
|
dfc = xcalloc(1, sizeof(struct cache_entry) + 1);
|
|
|
|
o->df_conflict_entry = dfc;
|
2006-07-30 18:25:18 +00:00
|
|
|
|
|
|
|
if (len) {
|
2008-03-06 04:15:44 +00:00
|
|
|
const char *prefix = o->prefix ? o->prefix : "";
|
|
|
|
struct traverse_info info;
|
|
|
|
|
|
|
|
setup_traverse_info(&info, prefix);
|
|
|
|
info.fn = unpack_callback;
|
|
|
|
info.data = o;
|
|
|
|
|
|
|
|
if (traverse_trees(len, t, &info) < 0)
|
|
|
|
return unpack_failed(o, NULL);
|
2006-07-30 18:25:18 +00:00
|
|
|
}
|
|
|
|
|
2008-03-06 04:15:44 +00:00
|
|
|
/* Any left-over entries in the index? */
|
|
|
|
if (o->merge) {
|
2008-03-07 02:12:28 +00:00
|
|
|
while (o->pos < o->src_index->cache_nr) {
|
|
|
|
struct cache_entry *ce = o->src_index->cache[o->pos];
|
2008-03-06 04:15:44 +00:00
|
|
|
if (unpack_index_entry(ce, o) < 0)
|
|
|
|
return unpack_failed(o, NULL);
|
2008-02-07 16:39:52 +00:00
|
|
|
}
|
|
|
|
}
|
2006-07-30 18:25:18 +00:00
|
|
|
|
2008-03-06 04:15:44 +00:00
|
|
|
if (o->trivial_merges_only && o->nontrivial_merge)
|
|
|
|
return unpack_failed(o, "Merge requires file-level merging");
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
o->src_index = NULL;
|
Discard "deleted" cache entries after using them to update the working tree
Way back in read-tree.c, we used a mode 0 cache entry to indicate that
an entry had been deleted, so that the update code would remove the
working tree file, and we would just skip it when writing out the
index file afterward.
These days, unpack_trees is a library function, and it is still
leaving these entries in the active cache. Furthermore, unpack_trees
doesn't correctly ignore those entries, and who knows what other code
wouldn't expect them to be there, but just isn't yet called after a
call to unpack_trees. To avoid having other code trip over these
entries, have check_updates() remove them after it removes the working
tree files.
While we're at it, simplify the loop in check_updates(), and avoid
passing global variables as parameters to check_updates(): there is
only one call site anyway.
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
2008-02-07 16:39:59 +00:00
|
|
|
check_updates(o);
|
2008-03-07 02:12:28 +00:00
|
|
|
if (o->dst_index)
|
|
|
|
*o->dst_index = o->result;
|
2006-07-30 18:25:18 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2006-07-30 18:26:15 +00:00
|
|
|
|
|
|
|
/* Here come the merge functions */
|
|
|
|
|
2008-02-07 16:39:48 +00:00
|
|
|
static int reject_merge(struct cache_entry *ce)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
2008-02-07 16:39:48 +00:00
|
|
|
return error("Entry '%s' would be overwritten by merge. Cannot merge.",
|
|
|
|
ce->name);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int same(struct cache_entry *a, struct cache_entry *b)
|
|
|
|
{
|
|
|
|
if (!!a != !!b)
|
|
|
|
return 0;
|
|
|
|
if (!a && !b)
|
|
|
|
return 1;
|
|
|
|
return a->ce_mode == b->ce_mode &&
|
2006-08-17 18:54:57 +00:00
|
|
|
!hashcmp(a->sha1, b->sha1);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When a CE gets turned into an unmerged entry, we
|
|
|
|
* want it to be up-to-date
|
|
|
|
*/
|
2008-02-07 16:39:48 +00:00
|
|
|
static int verify_uptodate(struct cache_entry *ce,
|
2006-07-30 18:26:15 +00:00
|
|
|
struct unpack_trees_options *o)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (o->index_only || o->reset)
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2006-07-30 18:26:15 +00:00
|
|
|
|
|
|
|
if (!lstat(ce->name, &st)) {
|
2008-03-07 02:12:28 +00:00
|
|
|
unsigned changed = ie_match_stat(o->src_index, ce, &st, CE_MATCH_IGNORE_VALID);
|
2006-07-30 18:26:15 +00:00
|
|
|
if (!changed)
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
unpack-trees.c: assume submodules are clean during check-out
Sven originally raised this issue:
If you have a submodule checked out and you go back (or
forward) to a revision of the supermodule that contains a
different revision of the submodule and then switch to
another revision, it will complain that the submodule is not
uptodate, because git simply didn't update the submodule in
the first move.
The current policy is to consider it is perfectly normal that
checked-out submodule is out-of-sync wrt the supermodule index.
At least until we introduce a superproject repository
configuration option that says "in this repository, I do care
about this submodule and at any time I move around in the
superproject, recursively check out the submodule to match", it
is a reasonable policy, as we currently do not recursively
checkout the submodules at all. The most extreme case of this
policy is that the superproject index knows about the submodule
but the subdirectory does not even have to be checked out.
The function verify_uptodate(), called during the two-way merge
aka branch switching, is about "make sure the filesystem entity
that corresponds to this cache entry is up to date, lest we lose
the local modifications". As we explicitly allow submodule
checkout to drift from the supermodule index entry, the check
should say "Ok, for submodules, not matching is the norm" for
now.
Later when we have the ability to mark "I care about this
submodule to be always in sync with the superproject" (thereby
implementing automatic recursive checkout and perhaps diff,
among other things), we should check if the submodule in
question is marked as such and perform the current test.
Acked-by: Lars Hjemli <hjemli@gmail.com>
Acked-by: Sven Verdoolaege <skimo@kotnet.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-08-04 05:13:09 +00:00
|
|
|
/*
|
|
|
|
* NEEDSWORK: the current default policy is to allow
|
|
|
|
* submodule to be out of sync wrt the supermodule
|
|
|
|
* index. This needs to be tightened later for
|
|
|
|
* submodules that are marked to be automatically
|
|
|
|
* checked out.
|
|
|
|
*/
|
2008-01-15 00:03:17 +00:00
|
|
|
if (S_ISGITLINK(ce->ce_mode))
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2006-07-30 18:26:15 +00:00
|
|
|
errno = 0;
|
|
|
|
}
|
|
|
|
if (errno == ENOENT)
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2008-02-07 16:39:52 +00:00
|
|
|
return o->gently ? -1 :
|
|
|
|
error("Entry '%s' not uptodate. Cannot merge.", ce->name);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
2008-03-06 20:26:14 +00:00
|
|
|
static void invalidate_ce_path(struct cache_entry *ce, struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
|
|
|
if (ce)
|
2008-03-07 02:12:28 +00:00
|
|
|
cache_tree_invalidate_path(o->src_index->cache_tree, ce->name);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
2007-07-17 18:28:28 +00:00
|
|
|
/*
|
|
|
|
* Check that checking out ce->sha1 in subdir ce->name is not
|
|
|
|
* going to overwrite any working files.
|
|
|
|
*
|
|
|
|
* Currently, git does not checkout subprojects during a superproject
|
|
|
|
* checkout, so it is not going to overwrite anything.
|
|
|
|
*/
|
|
|
|
static int verify_clean_submodule(struct cache_entry *ce, const char *action,
|
|
|
|
struct unpack_trees_options *o)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int verify_clean_subdirectory(struct cache_entry *ce, const char *action,
|
2007-03-16 06:25:22 +00:00
|
|
|
struct unpack_trees_options *o)
|
|
|
|
{
|
|
|
|
/*
|
2007-07-17 18:28:28 +00:00
|
|
|
* we are about to extract "ce->name"; we would not want to lose
|
2007-03-16 06:25:22 +00:00
|
|
|
* anything in the existing directory there.
|
|
|
|
*/
|
|
|
|
int namelen;
|
|
|
|
int pos, i;
|
|
|
|
struct dir_struct d;
|
|
|
|
char *pathbuf;
|
|
|
|
int cnt = 0;
|
2007-07-17 18:28:28 +00:00
|
|
|
unsigned char sha1[20];
|
|
|
|
|
2008-01-15 00:03:17 +00:00
|
|
|
if (S_ISGITLINK(ce->ce_mode) &&
|
2007-07-17 18:28:28 +00:00
|
|
|
resolve_gitlink_ref(ce->name, "HEAD", sha1) == 0) {
|
|
|
|
/* If we are not going to update the submodule, then
|
|
|
|
* we don't care.
|
|
|
|
*/
|
|
|
|
if (!hashcmp(sha1, ce->sha1))
|
|
|
|
return 0;
|
|
|
|
return verify_clean_submodule(ce, action, o);
|
|
|
|
}
|
2007-03-16 06:25:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* First let's make sure we do not have a local modification
|
|
|
|
* in that directory.
|
|
|
|
*/
|
2007-07-17 18:28:28 +00:00
|
|
|
namelen = strlen(ce->name);
|
2008-03-07 02:12:28 +00:00
|
|
|
pos = index_name_pos(o->src_index, ce->name, namelen);
|
2007-03-16 06:25:22 +00:00
|
|
|
if (0 <= pos)
|
|
|
|
return cnt; /* we have it as nondirectory */
|
|
|
|
pos = -pos - 1;
|
2008-03-07 02:12:28 +00:00
|
|
|
for (i = pos; i < o->src_index->cache_nr; i++) {
|
|
|
|
struct cache_entry *ce = o->src_index->cache[i];
|
2007-03-16 06:25:22 +00:00
|
|
|
int len = ce_namelen(ce);
|
|
|
|
if (len < namelen ||
|
2007-07-17 18:28:28 +00:00
|
|
|
strncmp(ce->name, ce->name, namelen) ||
|
2007-03-16 06:25:22 +00:00
|
|
|
ce->name[namelen] != '/')
|
|
|
|
break;
|
|
|
|
/*
|
|
|
|
* ce->name is an entry in the subdirectory.
|
|
|
|
*/
|
|
|
|
if (!ce_stage(ce)) {
|
2008-02-07 16:39:48 +00:00
|
|
|
if (verify_uptodate(ce, o))
|
|
|
|
return -1;
|
2008-03-07 02:12:28 +00:00
|
|
|
add_entry(o, ce, CE_REMOVE, 0);
|
2007-03-16 06:25:22 +00:00
|
|
|
}
|
|
|
|
cnt++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Then we need to make sure that we do not lose a locally
|
|
|
|
* present file that is not ignored.
|
|
|
|
*/
|
|
|
|
pathbuf = xmalloc(namelen + 2);
|
2007-07-17 18:28:28 +00:00
|
|
|
memcpy(pathbuf, ce->name, namelen);
|
2007-03-16 06:25:22 +00:00
|
|
|
strcpy(pathbuf+namelen, "/");
|
|
|
|
|
|
|
|
memset(&d, 0, sizeof(d));
|
|
|
|
if (o->dir)
|
|
|
|
d.exclude_per_dir = o->dir->exclude_per_dir;
|
2007-07-17 18:28:28 +00:00
|
|
|
i = read_directory(&d, ce->name, pathbuf, namelen+1, NULL);
|
2007-03-16 06:25:22 +00:00
|
|
|
if (i)
|
2008-02-07 16:39:52 +00:00
|
|
|
return o->gently ? -1 :
|
|
|
|
error("Updating '%s' would lose untracked files in it",
|
|
|
|
ce->name);
|
2007-03-16 06:25:22 +00:00
|
|
|
free(pathbuf);
|
|
|
|
return cnt;
|
|
|
|
}
|
|
|
|
|
2006-07-30 18:26:15 +00:00
|
|
|
/*
|
|
|
|
* We do not want to remove or overwrite a working tree file that
|
2006-12-05 00:00:46 +00:00
|
|
|
* is not tracked, unless it is ignored.
|
2006-07-30 18:26:15 +00:00
|
|
|
*/
|
2008-02-07 16:39:48 +00:00
|
|
|
static int verify_absent(struct cache_entry *ce, const char *action,
|
|
|
|
struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (o->index_only || o->reset || !o->update)
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2007-03-16 06:25:22 +00:00
|
|
|
|
2007-07-17 18:28:28 +00:00
|
|
|
if (has_symlink_leading_path(ce->name, NULL))
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2007-07-12 08:04:16 +00:00
|
|
|
|
2007-07-17 18:28:28 +00:00
|
|
|
if (!lstat(ce->name, &st)) {
|
2007-03-16 06:25:22 +00:00
|
|
|
int cnt;
|
2008-02-01 04:23:25 +00:00
|
|
|
int dtype = ce_to_dtype(ce);
|
2007-03-16 06:25:22 +00:00
|
|
|
|
2008-02-01 04:23:25 +00:00
|
|
|
if (o->dir && excluded(o->dir, ce->name, &dtype))
|
2007-03-16 06:25:22 +00:00
|
|
|
/*
|
2007-07-17 18:28:28 +00:00
|
|
|
* ce->name is explicitly excluded, so it is Ok to
|
2007-03-16 06:25:22 +00:00
|
|
|
* overwrite it.
|
|
|
|
*/
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2007-03-16 06:25:22 +00:00
|
|
|
if (S_ISDIR(st.st_mode)) {
|
|
|
|
/*
|
|
|
|
* We are checking out path "foo" and
|
|
|
|
* found "foo/." in the working tree.
|
|
|
|
* This is tricky -- if we have modified
|
|
|
|
* files that are in "foo/" we would lose
|
|
|
|
* it.
|
|
|
|
*/
|
2007-07-17 18:28:28 +00:00
|
|
|
cnt = verify_clean_subdirectory(ce, action, o);
|
2007-03-16 06:25:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If this removed entries from the index,
|
|
|
|
* what that means is:
|
|
|
|
*
|
|
|
|
* (1) the caller unpack_trees_rec() saw path/foo
|
|
|
|
* in the index, and it has not removed it because
|
|
|
|
* it thinks it is handling 'path' as blob with
|
|
|
|
* D/F conflict;
|
|
|
|
* (2) we will return "ok, we placed a merged entry
|
|
|
|
* in the index" which would cause o->pos to be
|
|
|
|
* incremented by one;
|
|
|
|
* (3) however, original o->pos now has 'path/foo'
|
|
|
|
* marked with "to be removed".
|
|
|
|
*
|
|
|
|
* We need to increment it by the number of
|
|
|
|
* deleted entries here.
|
|
|
|
*/
|
|
|
|
o->pos += cnt;
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2007-03-16 06:25:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The previous round may already have decided to
|
|
|
|
* delete this path, which is in a subdirectory that
|
|
|
|
* is being replaced with a blob.
|
|
|
|
*/
|
2008-03-07 02:12:28 +00:00
|
|
|
cnt = index_name_pos(&o->result, ce->name, strlen(ce->name));
|
2007-03-16 06:25:22 +00:00
|
|
|
if (0 <= cnt) {
|
2008-03-07 02:12:28 +00:00
|
|
|
struct cache_entry *ce = o->result.cache[cnt];
|
2008-01-15 00:03:17 +00:00
|
|
|
if (ce->ce_flags & CE_REMOVE)
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2007-03-16 06:25:22 +00:00
|
|
|
}
|
|
|
|
|
2008-02-07 16:39:52 +00:00
|
|
|
return o->gently ? -1 :
|
|
|
|
error("Untracked working tree file '%s' "
|
|
|
|
"would be %s by merge.", ce->name, action);
|
2007-03-16 06:25:22 +00:00
|
|
|
}
|
2008-02-07 16:39:48 +00:00
|
|
|
return 0;
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int merged_entry(struct cache_entry *merge, struct cache_entry *old,
|
|
|
|
struct unpack_trees_options *o)
|
|
|
|
{
|
|
|
|
if (old) {
|
|
|
|
/*
|
|
|
|
* See if we can re-use the old CE directly?
|
|
|
|
* That way we get the uptodate stat info.
|
|
|
|
*
|
|
|
|
* This also removes the UPDATE flag on
|
|
|
|
* a match.
|
|
|
|
*/
|
|
|
|
if (same(old, merge)) {
|
2008-02-23 04:41:17 +00:00
|
|
|
copy_cache_entry(merge, old);
|
2006-07-30 18:26:15 +00:00
|
|
|
} else {
|
2008-02-07 16:39:48 +00:00
|
|
|
if (verify_uptodate(old, o))
|
|
|
|
return -1;
|
2008-03-06 20:26:14 +00:00
|
|
|
invalidate_ce_path(old, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2008-02-07 16:39:48 +00:00
|
|
|
if (verify_absent(merge, "overwritten", o))
|
|
|
|
return -1;
|
2008-03-06 20:26:14 +00:00
|
|
|
invalidate_ce_path(merge, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
add_entry(o, merge, CE_UPDATE, CE_STAGEMASK);
|
2006-07-30 18:26:15 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int deleted_entry(struct cache_entry *ce, struct cache_entry *old,
|
|
|
|
struct unpack_trees_options *o)
|
|
|
|
{
|
2008-03-07 02:12:28 +00:00
|
|
|
/* Did it exist in the index? */
|
|
|
|
if (!old) {
|
2008-02-07 16:39:48 +00:00
|
|
|
if (verify_absent(ce, "removed", o))
|
|
|
|
return -1;
|
2008-03-07 02:12:28 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (verify_uptodate(old, o))
|
|
|
|
return -1;
|
|
|
|
add_entry(o, ce, CE_REMOVE, 0);
|
2008-03-06 20:26:14 +00:00
|
|
|
invalidate_ce_path(ce, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-04-02 07:06:12 +00:00
|
|
|
static int keep_entry(struct cache_entry *ce, struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
2008-03-07 02:12:28 +00:00
|
|
|
add_entry(o, ce, 0, 0);
|
2006-07-30 18:26:15 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if DBRT_DEBUG
|
|
|
|
static void show_stage_entry(FILE *o,
|
|
|
|
const char *label, const struct cache_entry *ce)
|
|
|
|
{
|
|
|
|
if (!ce)
|
|
|
|
fprintf(o, "%s (missing)\n", label);
|
|
|
|
else
|
|
|
|
fprintf(o, "%s%06o %s %d\t%s\n",
|
|
|
|
label,
|
2008-01-15 00:03:17 +00:00
|
|
|
ce->ce_mode,
|
2006-07-30 18:26:15 +00:00
|
|
|
sha1_to_hex(ce->sha1),
|
|
|
|
ce_stage(ce),
|
|
|
|
ce->name);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
int threeway_merge(struct cache_entry **stages, struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
|
|
|
struct cache_entry *index;
|
|
|
|
struct cache_entry *head;
|
|
|
|
struct cache_entry *remote = stages[o->head_idx + 1];
|
|
|
|
int count;
|
|
|
|
int head_match = 0;
|
|
|
|
int remote_match = 0;
|
|
|
|
|
|
|
|
int df_conflict_head = 0;
|
|
|
|
int df_conflict_remote = 0;
|
|
|
|
|
|
|
|
int any_anc_missing = 0;
|
|
|
|
int no_anc_exists = 1;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 1; i < o->head_idx; i++) {
|
2007-04-07 12:49:19 +00:00
|
|
|
if (!stages[i] || stages[i] == o->df_conflict_entry)
|
2006-07-30 18:26:15 +00:00
|
|
|
any_anc_missing = 1;
|
2007-04-07 12:49:19 +00:00
|
|
|
else
|
2006-07-30 18:26:15 +00:00
|
|
|
no_anc_exists = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
index = stages[0];
|
|
|
|
head = stages[o->head_idx];
|
|
|
|
|
|
|
|
if (head == o->df_conflict_entry) {
|
|
|
|
df_conflict_head = 1;
|
|
|
|
head = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (remote == o->df_conflict_entry) {
|
|
|
|
df_conflict_remote = 1;
|
|
|
|
remote = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* First, if there's a #16 situation, note that to prevent #13
|
|
|
|
* and #14.
|
|
|
|
*/
|
|
|
|
if (!same(remote, head)) {
|
|
|
|
for (i = 1; i < o->head_idx; i++) {
|
|
|
|
if (same(stages[i], head)) {
|
|
|
|
head_match = i;
|
|
|
|
}
|
|
|
|
if (same(stages[i], remote)) {
|
|
|
|
remote_match = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We start with cases where the index is allowed to match
|
|
|
|
* something other than the head: #14(ALT) and #2ALT, where it
|
|
|
|
* is permitted to match the result instead.
|
|
|
|
*/
|
|
|
|
/* #14, #14ALT, #2ALT */
|
|
|
|
if (remote && !df_conflict_head && head_match && !remote_match) {
|
|
|
|
if (index && !same(index, remote) && !same(index, head))
|
2008-02-07 16:39:52 +00:00
|
|
|
return o->gently ? -1 : reject_merge(index);
|
2006-07-30 18:26:15 +00:00
|
|
|
return merged_entry(remote, index, o);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If we have an entry in the index cache, then we want to
|
|
|
|
* make sure that it matches head.
|
|
|
|
*/
|
2008-02-07 16:40:02 +00:00
|
|
|
if (index && !same(index, head))
|
2008-02-07 16:39:52 +00:00
|
|
|
return o->gently ? -1 : reject_merge(index);
|
2006-07-30 18:26:15 +00:00
|
|
|
|
|
|
|
if (head) {
|
|
|
|
/* #5ALT, #15 */
|
|
|
|
if (same(head, remote))
|
|
|
|
return merged_entry(head, index, o);
|
|
|
|
/* #13, #3ALT */
|
|
|
|
if (!df_conflict_remote && remote_match && !head_match)
|
|
|
|
return merged_entry(head, index, o);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* #1 */
|
2008-03-07 02:12:28 +00:00
|
|
|
if (!head && !remote && any_anc_missing)
|
2006-07-30 18:26:15 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Under the new "aggressive" rule, we resolve mostly trivial
|
|
|
|
* cases that we historically had git-merge-one-file resolve.
|
|
|
|
*/
|
|
|
|
if (o->aggressive) {
|
|
|
|
int head_deleted = !head && !df_conflict_head;
|
|
|
|
int remote_deleted = !remote && !df_conflict_remote;
|
2007-07-17 18:28:28 +00:00
|
|
|
struct cache_entry *ce = NULL;
|
2007-04-07 12:49:19 +00:00
|
|
|
|
|
|
|
if (index)
|
2007-07-17 18:28:28 +00:00
|
|
|
ce = index;
|
2007-04-07 12:49:19 +00:00
|
|
|
else if (head)
|
2007-07-17 18:28:28 +00:00
|
|
|
ce = head;
|
2007-04-07 12:49:19 +00:00
|
|
|
else if (remote)
|
2007-07-17 18:28:28 +00:00
|
|
|
ce = remote;
|
2007-04-07 12:49:19 +00:00
|
|
|
else {
|
|
|
|
for (i = 1; i < o->head_idx; i++) {
|
|
|
|
if (stages[i] && stages[i] != o->df_conflict_entry) {
|
2007-07-17 18:28:28 +00:00
|
|
|
ce = stages[i];
|
2007-04-07 12:49:19 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-30 18:26:15 +00:00
|
|
|
/*
|
|
|
|
* Deleted in both.
|
|
|
|
* Deleted in one and unchanged in the other.
|
|
|
|
*/
|
|
|
|
if ((head_deleted && remote_deleted) ||
|
|
|
|
(head_deleted && remote && remote_match) ||
|
|
|
|
(remote_deleted && head && head_match)) {
|
|
|
|
if (index)
|
|
|
|
return deleted_entry(index, index, o);
|
2008-03-07 02:12:28 +00:00
|
|
|
if (ce && !head_deleted) {
|
2008-02-07 16:39:48 +00:00
|
|
|
if (verify_absent(ce, "removed", o))
|
|
|
|
return -1;
|
|
|
|
}
|
2006-07-30 18:26:15 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Added in both, identically.
|
|
|
|
*/
|
|
|
|
if (no_anc_exists && head && remote && same(head, remote))
|
|
|
|
return merged_entry(head, index, o);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Below are "no merge" cases, which require that the index be
|
|
|
|
* up-to-date to avoid the files getting overwritten with
|
|
|
|
* conflict resolution files.
|
|
|
|
*/
|
|
|
|
if (index) {
|
2008-02-07 16:39:48 +00:00
|
|
|
if (verify_uptodate(index, o))
|
|
|
|
return -1;
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
o->nontrivial_merge = 1;
|
|
|
|
|
2007-04-07 12:42:01 +00:00
|
|
|
/* #2, #3, #4, #6, #7, #9, #10, #11. */
|
2006-07-30 18:26:15 +00:00
|
|
|
count = 0;
|
|
|
|
if (!head_match || !remote_match) {
|
|
|
|
for (i = 1; i < o->head_idx; i++) {
|
2007-04-07 12:49:19 +00:00
|
|
|
if (stages[i] && stages[i] != o->df_conflict_entry) {
|
2007-04-02 07:06:12 +00:00
|
|
|
keep_entry(stages[i], o);
|
2006-07-30 18:26:15 +00:00
|
|
|
count++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#if DBRT_DEBUG
|
|
|
|
else {
|
|
|
|
fprintf(stderr, "read-tree: warning #16 detected\n");
|
|
|
|
show_stage_entry(stderr, "head ", stages[head_match]);
|
|
|
|
show_stage_entry(stderr, "remote ", stages[remote_match]);
|
|
|
|
}
|
|
|
|
#endif
|
2007-04-02 07:06:12 +00:00
|
|
|
if (head) { count += keep_entry(head, o); }
|
|
|
|
if (remote) { count += keep_entry(remote, o); }
|
2006-07-30 18:26:15 +00:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Two-way merge.
|
|
|
|
*
|
|
|
|
* The rule is to "carry forward" what is in the index without losing
|
|
|
|
* information across a "fast forward", favoring a successful merge
|
|
|
|
* over a merge failure when it makes sense. For details of the
|
|
|
|
* "carry forward" rule, please see <Documentation/git-read-tree.txt>.
|
|
|
|
*
|
|
|
|
*/
|
2008-03-07 02:12:28 +00:00
|
|
|
int twoway_merge(struct cache_entry **src, struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
|
|
|
struct cache_entry *current = src[0];
|
2007-04-02 23:29:56 +00:00
|
|
|
struct cache_entry *oldtree = src[1];
|
|
|
|
struct cache_entry *newtree = src[2];
|
2006-07-30 18:26:15 +00:00
|
|
|
|
|
|
|
if (o->merge_size != 2)
|
|
|
|
return error("Cannot do a twoway merge of %d trees",
|
|
|
|
o->merge_size);
|
|
|
|
|
2007-04-02 23:29:56 +00:00
|
|
|
if (oldtree == o->df_conflict_entry)
|
|
|
|
oldtree = NULL;
|
|
|
|
if (newtree == o->df_conflict_entry)
|
|
|
|
newtree = NULL;
|
|
|
|
|
2006-07-30 18:26:15 +00:00
|
|
|
if (current) {
|
|
|
|
if ((!oldtree && !newtree) || /* 4 and 5 */
|
|
|
|
(!oldtree && newtree &&
|
|
|
|
same(current, newtree)) || /* 6 and 7 */
|
|
|
|
(oldtree && newtree &&
|
|
|
|
same(oldtree, newtree)) || /* 14 and 15 */
|
|
|
|
(oldtree && newtree &&
|
2007-04-02 23:29:56 +00:00
|
|
|
!same(oldtree, newtree) && /* 18 and 19 */
|
2006-07-30 18:26:15 +00:00
|
|
|
same(current, newtree))) {
|
2007-04-02 07:06:12 +00:00
|
|
|
return keep_entry(current, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
else if (oldtree && !newtree && same(current, oldtree)) {
|
|
|
|
/* 10 or 11 */
|
|
|
|
return deleted_entry(oldtree, current, o);
|
|
|
|
}
|
|
|
|
else if (oldtree && newtree &&
|
|
|
|
same(current, oldtree) && !same(current, newtree)) {
|
|
|
|
/* 20 or 21 */
|
|
|
|
return merged_entry(newtree, current, o);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* all other failures */
|
|
|
|
if (oldtree)
|
2008-02-07 16:39:52 +00:00
|
|
|
return o->gently ? -1 : reject_merge(oldtree);
|
2006-07-30 18:26:15 +00:00
|
|
|
if (current)
|
2008-02-07 16:39:52 +00:00
|
|
|
return o->gently ? -1 : reject_merge(current);
|
2006-07-30 18:26:15 +00:00
|
|
|
if (newtree)
|
2008-02-07 16:39:52 +00:00
|
|
|
return o->gently ? -1 : reject_merge(newtree);
|
2006-07-30 18:26:15 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (newtree)
|
|
|
|
return merged_entry(newtree, current, o);
|
2007-08-10 19:31:20 +00:00
|
|
|
return deleted_entry(oldtree, current, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Bind merge.
|
|
|
|
*
|
|
|
|
* Keep the index entries at stage0, collapse stage1 but make sure
|
|
|
|
* stage0 does not have anything there.
|
|
|
|
*/
|
|
|
|
int bind_merge(struct cache_entry **src,
|
2008-03-07 02:12:28 +00:00
|
|
|
struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
|
|
|
struct cache_entry *old = src[0];
|
|
|
|
struct cache_entry *a = src[1];
|
|
|
|
|
|
|
|
if (o->merge_size != 1)
|
|
|
|
return error("Cannot do a bind merge of %d trees\n",
|
|
|
|
o->merge_size);
|
|
|
|
if (a && old)
|
2008-02-07 16:39:52 +00:00
|
|
|
return o->gently ? -1 :
|
2008-03-07 02:12:28 +00:00
|
|
|
error("Entry '%s' overlaps with '%s'. Cannot bind.", a->name, old->name);
|
2006-07-30 18:26:15 +00:00
|
|
|
if (!a)
|
2007-04-02 07:06:12 +00:00
|
|
|
return keep_entry(old, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
else
|
|
|
|
return merged_entry(a, NULL, o);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* One-way merge.
|
|
|
|
*
|
|
|
|
* The rule is:
|
|
|
|
* - take the stat information from stage0, take the data from stage1
|
|
|
|
*/
|
2008-03-07 02:12:28 +00:00
|
|
|
int oneway_merge(struct cache_entry **src, struct unpack_trees_options *o)
|
2006-07-30 18:26:15 +00:00
|
|
|
{
|
|
|
|
struct cache_entry *old = src[0];
|
|
|
|
struct cache_entry *a = src[1];
|
|
|
|
|
|
|
|
if (o->merge_size != 1)
|
|
|
|
return error("Cannot do a oneway merge of %d trees",
|
|
|
|
o->merge_size);
|
|
|
|
|
2008-03-07 02:12:28 +00:00
|
|
|
if (!a)
|
2006-07-30 18:26:15 +00:00
|
|
|
return deleted_entry(old, old, o);
|
2008-03-07 02:12:28 +00:00
|
|
|
|
2006-07-30 18:26:15 +00:00
|
|
|
if (old && same(old, a)) {
|
2008-03-07 02:12:28 +00:00
|
|
|
int update = 0;
|
2006-07-30 18:26:15 +00:00
|
|
|
if (o->reset) {
|
|
|
|
struct stat st;
|
|
|
|
if (lstat(old->name, &st) ||
|
2008-03-07 02:12:28 +00:00
|
|
|
ie_match_stat(o->src_index, old, &st, CE_MATCH_IGNORE_VALID))
|
|
|
|
update |= CE_UPDATE;
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
2008-03-07 02:12:28 +00:00
|
|
|
add_entry(o, old, update, 0);
|
|
|
|
return 0;
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
return merged_entry(a, old, o);
|
|
|
|
}
|