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
|
|
|
|
2006-07-30 18:26:15 +00:00
|
|
|
#define DBRT_DEBUG 1
|
|
|
|
|
2006-07-30 18:25:18 +00:00
|
|
|
struct tree_entry_list {
|
|
|
|
struct tree_entry_list *next;
|
|
|
|
unsigned int mode;
|
|
|
|
const char *name;
|
|
|
|
const unsigned char *sha1;
|
|
|
|
};
|
|
|
|
|
2007-08-10 05:21:29 +00:00
|
|
|
static struct tree_entry_list *create_tree_entry_list(struct tree_desc *desc)
|
2006-07-30 18:25:18 +00:00
|
|
|
{
|
|
|
|
struct name_entry one;
|
|
|
|
struct tree_entry_list *ret = NULL;
|
|
|
|
struct tree_entry_list **list_p = &ret;
|
|
|
|
|
2007-08-10 05:21:29 +00:00
|
|
|
while (tree_entry(desc, &one)) {
|
2006-07-30 18:25:18 +00:00
|
|
|
struct tree_entry_list *entry;
|
|
|
|
|
|
|
|
entry = xmalloc(sizeof(struct tree_entry_list));
|
|
|
|
entry->name = one.path;
|
|
|
|
entry->sha1 = one.sha1;
|
|
|
|
entry->mode = one.mode;
|
|
|
|
entry->next = NULL;
|
|
|
|
|
|
|
|
*list_p = entry;
|
|
|
|
list_p = &entry->next;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int entcmp(const char *name1, int dir1, const char *name2, int dir2)
|
|
|
|
{
|
|
|
|
int len1 = strlen(name1);
|
|
|
|
int len2 = strlen(name2);
|
|
|
|
int len = len1 < len2 ? len1 : len2;
|
|
|
|
int ret = memcmp(name1, name2, len);
|
|
|
|
unsigned char c1, c2;
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
c1 = name1[len];
|
|
|
|
c2 = name2[len];
|
|
|
|
if (!c1 && dir1)
|
|
|
|
c1 = '/';
|
|
|
|
if (!c2 && dir2)
|
|
|
|
c2 = '/';
|
|
|
|
ret = (c1 < c2) ? -1 : (c1 > c2) ? 1 : 0;
|
|
|
|
if (c1 && c2 && !ret)
|
|
|
|
ret = len1 - len2;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-08-10 19:15:54 +00:00
|
|
|
static inline void remove_entry(int remove)
|
|
|
|
{
|
|
|
|
if (remove >= 0)
|
|
|
|
remove_cache_entry_at(remove);
|
|
|
|
}
|
|
|
|
|
2006-07-30 18:25:18 +00:00
|
|
|
static int unpack_trees_rec(struct tree_entry_list **posns, int len,
|
|
|
|
const char *base, struct unpack_trees_options *o,
|
|
|
|
struct tree_entry_list *df_conflict_list)
|
|
|
|
{
|
2007-08-10 19:15:54 +00:00
|
|
|
int remove;
|
2006-07-30 18:25:18 +00:00
|
|
|
int baselen = strlen(base);
|
|
|
|
int src_size = len + 1;
|
2006-12-05 00:00:46 +00:00
|
|
|
int retval = 0;
|
|
|
|
|
2006-07-30 18:25:18 +00:00
|
|
|
do {
|
|
|
|
int i;
|
|
|
|
const char *first;
|
|
|
|
int firstdir = 0;
|
|
|
|
int pathlen;
|
|
|
|
unsigned ce_size;
|
|
|
|
struct tree_entry_list **subposns;
|
|
|
|
struct cache_entry **src;
|
|
|
|
int any_files = 0;
|
|
|
|
int any_dirs = 0;
|
|
|
|
char *cache_name;
|
|
|
|
int ce_stage;
|
|
|
|
|
|
|
|
/* Find the first name in the input. */
|
|
|
|
|
|
|
|
first = NULL;
|
|
|
|
cache_name = NULL;
|
|
|
|
|
|
|
|
/* Check the cache */
|
2007-04-02 22:06:59 +00:00
|
|
|
if (o->merge && o->pos < active_nr) {
|
2006-07-30 18:25:18 +00:00
|
|
|
/* This is a bit tricky: */
|
|
|
|
/* If the index has a subdirectory (with
|
|
|
|
* contents) as the first name, it'll get a
|
|
|
|
* filename like "foo/bar". But that's after
|
|
|
|
* "foo", so the entry in trees will get
|
|
|
|
* handled first, at which point we'll go into
|
|
|
|
* "foo", and deal with "bar" from the index,
|
|
|
|
* because the base will be "foo/". The only
|
|
|
|
* way we can actually have "foo/bar" first of
|
|
|
|
* all the things is if the trees don't
|
|
|
|
* contain "foo" at all, in which case we'll
|
|
|
|
* handle "foo/bar" without going into the
|
|
|
|
* directory, but that's fine (and will return
|
|
|
|
* an error anyway, with the added unknown
|
|
|
|
* file case.
|
|
|
|
*/
|
|
|
|
|
2007-04-02 22:06:59 +00:00
|
|
|
cache_name = active_cache[o->pos]->name;
|
2006-07-30 18:25:18 +00:00
|
|
|
if (strlen(cache_name) > baselen &&
|
|
|
|
!memcmp(cache_name, base, baselen)) {
|
|
|
|
cache_name += baselen;
|
|
|
|
first = cache_name;
|
|
|
|
} else {
|
|
|
|
cache_name = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#if DBRT_DEBUG > 1
|
|
|
|
if (first)
|
|
|
|
printf("index %s\n", first);
|
|
|
|
#endif
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if (!posns[i] || posns[i] == df_conflict_list)
|
|
|
|
continue;
|
|
|
|
#if DBRT_DEBUG > 1
|
|
|
|
printf("%d %s\n", i + 1, posns[i]->name);
|
|
|
|
#endif
|
|
|
|
if (!first || entcmp(first, firstdir,
|
|
|
|
posns[i]->name,
|
2007-07-24 21:54:25 +00:00
|
|
|
S_ISDIR(posns[i]->mode)) > 0) {
|
2006-07-30 18:25:18 +00:00
|
|
|
first = posns[i]->name;
|
2007-07-24 21:54:25 +00:00
|
|
|
firstdir = S_ISDIR(posns[i]->mode);
|
2006-07-30 18:25:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* No name means we're done */
|
|
|
|
if (!first)
|
2006-12-05 00:00:46 +00:00
|
|
|
goto leave_directory;
|
2006-07-30 18:25:18 +00:00
|
|
|
|
|
|
|
pathlen = strlen(first);
|
|
|
|
ce_size = cache_entry_size(baselen + pathlen);
|
|
|
|
|
|
|
|
src = xcalloc(src_size, sizeof(struct cache_entry *));
|
|
|
|
|
|
|
|
subposns = xcalloc(len, sizeof(struct tree_list_entry *));
|
|
|
|
|
2007-08-10 19:15:54 +00:00
|
|
|
remove = -1;
|
2006-07-30 18:25:18 +00:00
|
|
|
if (cache_name && !strcmp(cache_name, first)) {
|
|
|
|
any_files = 1;
|
2007-04-02 22:06:59 +00:00
|
|
|
src[0] = active_cache[o->pos];
|
2007-08-10 19:15:54 +00:00
|
|
|
remove = o->pos;
|
2006-07-30 18:25:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
struct cache_entry *ce;
|
|
|
|
|
|
|
|
if (!posns[i] ||
|
|
|
|
(posns[i] != df_conflict_list &&
|
|
|
|
strcmp(first, posns[i]->name))) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (posns[i] == df_conflict_list) {
|
|
|
|
src[i + o->merge] = o->df_conflict_entry;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2007-07-24 21:54:25 +00:00
|
|
|
if (S_ISDIR(posns[i]->mode)) {
|
2006-07-30 18:25:18 +00:00
|
|
|
struct tree *tree = lookup_tree(posns[i]->sha1);
|
2007-08-10 05:21:29 +00:00
|
|
|
struct tree_desc t;
|
2006-07-30 18:25:18 +00:00
|
|
|
any_dirs = 1;
|
|
|
|
parse_tree(tree);
|
2007-08-10 05:21:29 +00:00
|
|
|
init_tree_desc(&t, tree->buffer, tree->size);
|
|
|
|
subposns[i] = create_tree_entry_list(&t);
|
2006-07-30 18:25:18 +00:00
|
|
|
posns[i] = posns[i]->next;
|
|
|
|
src[i + o->merge] = o->df_conflict_entry;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!o->merge)
|
|
|
|
ce_stage = 0;
|
|
|
|
else if (i + 1 < o->head_idx)
|
|
|
|
ce_stage = 1;
|
|
|
|
else if (i + 1 > o->head_idx)
|
|
|
|
ce_stage = 3;
|
|
|
|
else
|
|
|
|
ce_stage = 2;
|
|
|
|
|
|
|
|
ce = xcalloc(1, ce_size);
|
|
|
|
ce->ce_mode = create_ce_mode(posns[i]->mode);
|
|
|
|
ce->ce_flags = create_ce_flags(baselen + pathlen,
|
|
|
|
ce_stage);
|
|
|
|
memcpy(ce->name, base, baselen);
|
|
|
|
memcpy(ce->name + baselen, first, pathlen + 1);
|
|
|
|
|
|
|
|
any_files = 1;
|
|
|
|
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(ce->sha1, posns[i]->sha1);
|
2006-07-30 18:25:18 +00:00
|
|
|
src[i + o->merge] = ce;
|
|
|
|
subposns[i] = df_conflict_list;
|
|
|
|
posns[i] = posns[i]->next;
|
|
|
|
}
|
|
|
|
if (any_files) {
|
|
|
|
if (o->merge) {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
#if DBRT_DEBUG > 1
|
|
|
|
printf("%s:\n", first);
|
|
|
|
for (i = 0; i < src_size; i++) {
|
|
|
|
printf(" %d ", i);
|
|
|
|
if (src[i])
|
|
|
|
printf("%s\n", sha1_to_hex(src[i]->sha1));
|
|
|
|
else
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
#endif
|
2007-08-10 19:15:54 +00:00
|
|
|
ret = o->fn(src, o, remove);
|
2006-07-30 18:25:18 +00:00
|
|
|
|
|
|
|
#if DBRT_DEBUG > 1
|
|
|
|
printf("Added %d entries\n", ret);
|
|
|
|
#endif
|
2007-04-02 22:06:59 +00:00
|
|
|
o->pos += ret;
|
2006-07-30 18:25:18 +00:00
|
|
|
} else {
|
2007-08-10 19:15:54 +00:00
|
|
|
remove_entry(remove);
|
2006-07-30 18:25:18 +00:00
|
|
|
for (i = 0; i < src_size; i++) {
|
|
|
|
if (src[i]) {
|
|
|
|
add_cache_entry(src[i], ADD_CACHE_OK_TO_ADD|ADD_CACHE_SKIP_DFCHECK);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (any_dirs) {
|
|
|
|
char *newbase = xmalloc(baselen + 2 + pathlen);
|
|
|
|
memcpy(newbase, base, baselen);
|
|
|
|
memcpy(newbase + baselen, first, pathlen);
|
|
|
|
newbase[baselen + pathlen] = '/';
|
|
|
|
newbase[baselen + pathlen + 1] = '\0';
|
|
|
|
if (unpack_trees_rec(subposns, len, newbase, o,
|
2007-04-02 22:06:59 +00:00
|
|
|
df_conflict_list)) {
|
2006-12-05 00:00:46 +00:00
|
|
|
retval = -1;
|
|
|
|
goto leave_directory;
|
|
|
|
}
|
2006-07-30 18:25:18 +00:00
|
|
|
free(newbase);
|
|
|
|
}
|
|
|
|
free(subposns);
|
|
|
|
free(src);
|
|
|
|
} while (1);
|
2006-12-05 00:00:46 +00:00
|
|
|
|
|
|
|
leave_directory:
|
|
|
|
return retval;
|
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;
|
|
|
|
static void check_updates(struct cache_entry **src, int nr,
|
2007-05-11 06:44:53 +00:00
|
|
|
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];
|
2006-07-30 18:25:18 +00:00
|
|
|
|
|
|
|
if (o->update && o->verbose_update) {
|
|
|
|
for (total = cnt = 0; cnt < nr; cnt++) {
|
|
|
|
struct cache_entry *ce = src[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",
|
|
|
|
total, 50, 2);
|
2006-07-30 18:25:18 +00:00
|
|
|
cnt = 0;
|
|
|
|
}
|
|
|
|
|
2007-05-11 06:44:53 +00:00
|
|
|
*last_symlink = '\0';
|
2006-07-30 18:25:18 +00:00
|
|
|
while (nr--) {
|
|
|
|
struct cache_entry *ce = *src++;
|
|
|
|
|
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);
|
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
|
|
|
}
|
|
|
|
|
2007-08-10 05:21:29 +00:00
|
|
|
int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options *o)
|
2006-07-30 18:25:18 +00:00
|
|
|
{
|
|
|
|
struct tree_entry_list **posns;
|
|
|
|
int i;
|
|
|
|
struct tree_entry_list df_conflict_list;
|
2006-12-04 10:11:39 +00:00
|
|
|
static struct cache_entry *dfc;
|
2006-07-30 18:25:18 +00:00
|
|
|
|
|
|
|
memset(&df_conflict_list, 0, sizeof(df_conflict_list));
|
|
|
|
df_conflict_list.next = &df_conflict_list;
|
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;
|
|
|
|
|
|
|
|
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) {
|
|
|
|
posns = xmalloc(len * sizeof(struct tree_entry_list *));
|
2007-08-10 05:21:29 +00:00
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
posns[i] = create_tree_entry_list(t+i);
|
|
|
|
|
2006-07-30 18:25:18 +00:00
|
|
|
if (unpack_trees_rec(posns, len, o->prefix ? o->prefix : "",
|
2007-04-02 22:06:59 +00:00
|
|
|
o, &df_conflict_list))
|
2006-07-30 18:25:18 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (o->trivial_merges_only && o->nontrivial_merge)
|
|
|
|
die("Merge requires file-level merging");
|
|
|
|
|
|
|
|
check_updates(active_cache, active_nr, o);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-07-30 18:26:15 +00:00
|
|
|
|
|
|
|
/* Here come the merge functions */
|
|
|
|
|
|
|
|
static void reject_merge(struct cache_entry *ce)
|
|
|
|
{
|
|
|
|
die("Entry '%s' would be overwritten by merge. Cannot merge.",
|
|
|
|
ce->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
*/
|
|
|
|
static void verify_uptodate(struct cache_entry *ce,
|
|
|
|
struct unpack_trees_options *o)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (o->index_only || o->reset)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!lstat(ce->name, &st)) {
|
2007-11-10 08:15:03 +00:00
|
|
|
unsigned changed = ce_match_stat(ce, &st, CE_MATCH_IGNORE_VALID);
|
2006-07-30 18:26:15 +00:00
|
|
|
if (!changed)
|
|
|
|
return;
|
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))
|
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
|
|
|
return;
|
2006-07-30 18:26:15 +00:00
|
|
|
errno = 0;
|
|
|
|
}
|
|
|
|
if (errno == ENOENT)
|
|
|
|
return;
|
|
|
|
die("Entry '%s' not uptodate. Cannot merge.", ce->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void invalidate_ce_path(struct cache_entry *ce)
|
|
|
|
{
|
|
|
|
if (ce)
|
|
|
|
cache_tree_invalidate_path(active_cache_tree, ce->name);
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
pos = cache_name_pos(ce->name, namelen);
|
2007-03-16 06:25:22 +00:00
|
|
|
if (0 <= pos)
|
|
|
|
return cnt; /* we have it as nondirectory */
|
|
|
|
pos = -pos - 1;
|
|
|
|
for (i = pos; i < active_nr; i++) {
|
|
|
|
struct cache_entry *ce = active_cache[i];
|
|
|
|
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)) {
|
|
|
|
verify_uptodate(ce, o);
|
2008-01-15 00:03:17 +00:00
|
|
|
ce->ce_flags |= CE_REMOVE;
|
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)
|
|
|
|
die("Updating '%s' would lose untracked files in it",
|
2007-07-17 18:28:28 +00:00
|
|
|
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
|
|
|
*/
|
2007-07-17 18:28:28 +00:00
|
|
|
static void verify_absent(struct cache_entry *ce, const char *action,
|
2006-07-30 18:26:15 +00:00
|
|
|
struct unpack_trees_options *o)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (o->index_only || o->reset || !o->update)
|
|
|
|
return;
|
2007-03-16 06:25:22 +00:00
|
|
|
|
2007-07-17 18:28:28 +00:00
|
|
|
if (has_symlink_leading_path(ce->name, NULL))
|
2007-07-12 08:04:16 +00:00
|
|
|
return;
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
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;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The previous round may already have decided to
|
|
|
|
* delete this path, which is in a subdirectory that
|
|
|
|
* is being replaced with a blob.
|
|
|
|
*/
|
2007-07-17 18:28:28 +00:00
|
|
|
cnt = cache_name_pos(ce->name, strlen(ce->name));
|
2007-03-16 06:25:22 +00:00
|
|
|
if (0 <= cnt) {
|
|
|
|
struct cache_entry *ce = active_cache[cnt];
|
2008-01-15 00:03:17 +00:00
|
|
|
if (ce->ce_flags & CE_REMOVE)
|
2007-03-16 06:25:22 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-07-30 18:26:15 +00:00
|
|
|
die("Untracked working tree file '%s' "
|
2007-07-17 18:28:28 +00:00
|
|
|
"would be %s by merge.", ce->name, action);
|
2007-03-16 06:25:22 +00:00
|
|
|
}
|
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)
|
|
|
|
{
|
2008-01-15 00:03:17 +00:00
|
|
|
merge->ce_flags |= CE_UPDATE;
|
2006-07-30 18:26:15 +00:00
|
|
|
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 {
|
|
|
|
verify_uptodate(old, o);
|
|
|
|
invalidate_ce_path(old);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2007-07-17 18:28:28 +00:00
|
|
|
verify_absent(merge, "overwritten", o);
|
2006-07-30 18:26:15 +00:00
|
|
|
invalidate_ce_path(merge);
|
|
|
|
}
|
|
|
|
|
2008-01-15 00:03:17 +00:00
|
|
|
merge->ce_flags &= ~CE_STAGEMASK;
|
2006-07-30 18:26:15 +00:00
|
|
|
add_cache_entry(merge, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int deleted_entry(struct cache_entry *ce, struct cache_entry *old,
|
|
|
|
struct unpack_trees_options *o)
|
|
|
|
{
|
|
|
|
if (old)
|
|
|
|
verify_uptodate(old, o);
|
|
|
|
else
|
2007-07-17 18:28:28 +00:00
|
|
|
verify_absent(ce, "removed", o);
|
2008-01-15 00:03:17 +00:00
|
|
|
ce->ce_flags |= CE_REMOVE;
|
2006-07-30 18:26:15 +00:00
|
|
|
add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);
|
|
|
|
invalidate_ce_path(ce);
|
|
|
|
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
|
|
|
{
|
|
|
|
add_cache_entry(ce, ADD_CACHE_OK_TO_ADD);
|
|
|
|
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
|
|
|
|
|
|
|
|
int threeway_merge(struct cache_entry **stages,
|
2007-08-10 19:15:54 +00:00
|
|
|
struct unpack_trees_options *o,
|
|
|
|
int remove)
|
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))
|
|
|
|
reject_merge(index);
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
if (index && !same(index, head)) {
|
|
|
|
reject_merge(index);
|
|
|
|
}
|
|
|
|
|
|
|
|
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 */
|
2007-08-10 19:53:51 +00:00
|
|
|
if (!head && !remote && any_anc_missing) {
|
|
|
|
remove_entry(remove);
|
2006-07-30 18:26:15 +00:00
|
|
|
return 0;
|
2007-08-10 19:53:51 +00:00
|
|
|
}
|
2006-07-30 18:26:15 +00:00
|
|
|
|
|
|
|
/* 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)) {
|
2007-08-10 19:53:51 +00:00
|
|
|
remove_entry(remove);
|
2006-07-30 18:26:15 +00:00
|
|
|
if (index)
|
|
|
|
return deleted_entry(index, index, o);
|
2007-07-17 18:28:28 +00:00
|
|
|
else if (ce && !head_deleted)
|
|
|
|
verify_absent(ce, "removed", o);
|
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) {
|
|
|
|
verify_uptodate(index, o);
|
|
|
|
}
|
|
|
|
|
2007-08-10 19:53:51 +00:00
|
|
|
remove_entry(remove);
|
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>.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
int twoway_merge(struct cache_entry **src,
|
2007-08-10 19:15:54 +00:00
|
|
|
struct unpack_trees_options *o,
|
|
|
|
int remove)
|
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 */
|
2007-08-10 19:31:20 +00:00
|
|
|
remove_entry(remove);
|
2006-07-30 18:26:15 +00:00
|
|
|
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 */
|
2007-08-10 19:31:20 +00:00
|
|
|
remove_entry(remove);
|
2006-07-30 18:26:15 +00:00
|
|
|
if (oldtree)
|
|
|
|
reject_merge(oldtree);
|
|
|
|
if (current)
|
|
|
|
reject_merge(current);
|
|
|
|
if (newtree)
|
|
|
|
reject_merge(newtree);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (newtree)
|
|
|
|
return merged_entry(newtree, current, o);
|
2007-08-10 19:31:20 +00:00
|
|
|
remove_entry(remove);
|
|
|
|
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,
|
2007-08-10 19:15:54 +00:00
|
|
|
struct unpack_trees_options *o,
|
|
|
|
int remove)
|
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)
|
|
|
|
die("Entry '%s' overlaps. Cannot bind.", a->name);
|
|
|
|
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
|
|
|
|
*/
|
|
|
|
int oneway_merge(struct cache_entry **src,
|
2007-08-10 19:15:54 +00:00
|
|
|
struct unpack_trees_options *o,
|
|
|
|
int remove)
|
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);
|
|
|
|
|
2007-08-10 19:21:20 +00:00
|
|
|
if (!a) {
|
|
|
|
remove_entry(remove);
|
2006-07-30 18:26:15 +00:00
|
|
|
return deleted_entry(old, old, o);
|
2007-08-10 19:21:20 +00:00
|
|
|
}
|
2006-07-30 18:26:15 +00:00
|
|
|
if (old && same(old, a)) {
|
|
|
|
if (o->reset) {
|
|
|
|
struct stat st;
|
|
|
|
if (lstat(old->name, &st) ||
|
2007-11-10 08:15:03 +00:00
|
|
|
ce_match_stat(old, &st, CE_MATCH_IGNORE_VALID))
|
2008-01-15 00:03:17 +00:00
|
|
|
old->ce_flags |= CE_UPDATE;
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
2007-04-02 07:06:12 +00:00
|
|
|
return keep_entry(old, o);
|
2006-07-30 18:26:15 +00:00
|
|
|
}
|
|
|
|
return merged_entry(a, old, o);
|
|
|
|
}
|