2005-04-07 22:16:10 +00:00
|
|
|
/*
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
*
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
*/
|
2005-09-06 19:53:56 +00:00
|
|
|
#define DBRT_DEBUG 1
|
|
|
|
|
2005-04-07 22:13:13 +00:00
|
|
|
#include "cache.h"
|
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
#include "object.h"
|
|
|
|
#include "tree.h"
|
2006-04-25 04:18:58 +00:00
|
|
|
#include "cache-tree.h"
|
2006-02-23 03:02:39 +00:00
|
|
|
#include <sys/time.h>
|
|
|
|
#include <signal.h>
|
2005-09-05 06:04:48 +00:00
|
|
|
|
|
|
|
static int merge = 0;
|
2005-06-06 05:07:31 +00:00
|
|
|
static int update = 0;
|
2005-09-11 00:46:27 +00:00
|
|
|
static int index_only = 0;
|
2005-09-29 15:16:12 +00:00
|
|
|
static int nontrivial_merge = 0;
|
|
|
|
static int trivial_merges_only = 0;
|
2006-02-04 06:04:14 +00:00
|
|
|
static int aggressive = 0;
|
2006-02-23 03:02:39 +00:00
|
|
|
static int verbose_update = 0;
|
|
|
|
static volatile int progress_update = 0;
|
2005-04-16 05:53:45 +00:00
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
static int head_idx = -1;
|
|
|
|
static int merge_size = 0;
|
2005-04-21 01:06:50 +00:00
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
static struct object_list *trees = NULL;
|
|
|
|
|
|
|
|
static struct cache_entry df_conflict_entry = {
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct tree_entry_list df_conflict_list = {
|
|
|
|
.name = NULL,
|
|
|
|
.next = &df_conflict_list
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef int (*merge_fn_t)(struct cache_entry **src);
|
|
|
|
|
|
|
|
static int entcmp(char *name1, int dir1, 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;
|
2005-05-11 21:16:23 +00:00
|
|
|
return ret;
|
2005-04-21 01:06:50 +00:00
|
|
|
}
|
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
static int unpack_trees_rec(struct tree_entry_list **posns, int len,
|
|
|
|
const char *base, merge_fn_t fn, int *indpos)
|
2005-04-19 18:16:12 +00:00
|
|
|
{
|
2005-09-05 06:04:48 +00:00
|
|
|
int baselen = strlen(base);
|
|
|
|
int src_size = len + 1;
|
|
|
|
do {
|
|
|
|
int i;
|
|
|
|
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 */
|
|
|
|
if (merge && *indpos < active_nr) {
|
|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
cache_name = active_cache[*indpos]->name;
|
|
|
|
if (strlen(cache_name) > baselen &&
|
|
|
|
!memcmp(cache_name, base, baselen)) {
|
|
|
|
cache_name += baselen;
|
|
|
|
first = cache_name;
|
|
|
|
} else {
|
|
|
|
cache_name = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-06 19:53:56 +00:00
|
|
|
#if DBRT_DEBUG > 1
|
2005-09-05 06:04:48 +00:00
|
|
|
if (first)
|
|
|
|
printf("index %s\n", first);
|
2005-09-05 08:13:36 +00:00
|
|
|
#endif
|
2005-09-05 06:04:48 +00:00
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if (!posns[i] || posns[i] == &df_conflict_list)
|
|
|
|
continue;
|
2005-09-06 19:53:56 +00:00
|
|
|
#if DBRT_DEBUG > 1
|
2005-09-05 06:04:48 +00:00
|
|
|
printf("%d %s\n", i + 1, posns[i]->name);
|
2005-09-05 08:13:36 +00:00
|
|
|
#endif
|
2005-09-05 06:04:48 +00:00
|
|
|
if (!first || entcmp(first, firstdir,
|
|
|
|
posns[i]->name,
|
|
|
|
posns[i]->directory) > 0) {
|
|
|
|
first = posns[i]->name;
|
|
|
|
firstdir = posns[i]->directory;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* No name means we're done */
|
|
|
|
if (!first)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
pathlen = strlen(first);
|
|
|
|
ce_size = cache_entry_size(baselen + pathlen);
|
|
|
|
|
2006-04-03 18:30:46 +00:00
|
|
|
src = xcalloc(src_size, sizeof(struct cache_entry *));
|
2005-09-05 06:04:48 +00:00
|
|
|
|
2006-04-03 18:30:46 +00:00
|
|
|
subposns = xcalloc(len, sizeof(struct tree_list_entry *));
|
2005-09-05 06:04:48 +00:00
|
|
|
|
|
|
|
if (cache_name && !strcmp(cache_name, first)) {
|
|
|
|
any_files = 1;
|
|
|
|
src[0] = active_cache[*indpos];
|
|
|
|
remove_cache_entry_at(*indpos);
|
|
|
|
}
|
|
|
|
|
|
|
|
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 + merge] = &df_conflict_entry;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (posns[i]->directory) {
|
|
|
|
any_dirs = 1;
|
|
|
|
parse_tree(posns[i]->item.tree);
|
|
|
|
subposns[i] = posns[i]->item.tree->entries;
|
|
|
|
posns[i] = posns[i]->next;
|
|
|
|
src[i + merge] = &df_conflict_entry;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!merge)
|
|
|
|
ce_stage = 0;
|
|
|
|
else if (i + 1 < head_idx)
|
|
|
|
ce_stage = 1;
|
|
|
|
else if (i + 1 > head_idx)
|
|
|
|
ce_stage = 3;
|
|
|
|
else
|
|
|
|
ce_stage = 2;
|
|
|
|
|
2006-04-03 18:30:46 +00:00
|
|
|
ce = xcalloc(1, ce_size);
|
2005-09-05 06:04:48 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
memcpy(ce->sha1, posns[i]->item.any->sha1, 20);
|
|
|
|
src[i + merge] = ce;
|
|
|
|
subposns[i] = &df_conflict_list;
|
|
|
|
posns[i] = posns[i]->next;
|
|
|
|
}
|
|
|
|
if (any_files) {
|
|
|
|
if (merge) {
|
|
|
|
int ret;
|
|
|
|
|
2005-09-06 19:53:56 +00:00
|
|
|
#if DBRT_DEBUG > 1
|
2005-09-05 06:04:48 +00:00
|
|
|
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");
|
|
|
|
}
|
2005-09-05 08:13:36 +00:00
|
|
|
#endif
|
2005-09-05 06:04:48 +00:00
|
|
|
ret = fn(src);
|
|
|
|
|
2005-09-06 19:53:56 +00:00
|
|
|
#if DBRT_DEBUG > 1
|
2005-09-05 06:04:48 +00:00
|
|
|
printf("Added %d entries\n", ret);
|
2005-09-05 08:13:36 +00:00
|
|
|
#endif
|
2005-09-05 06:04:48 +00:00
|
|
|
*indpos += ret;
|
|
|
|
} else {
|
|
|
|
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, fn,
|
|
|
|
indpos))
|
|
|
|
return -1;
|
2005-09-11 01:14:14 +00:00
|
|
|
free(newbase);
|
2005-09-05 06:04:48 +00:00
|
|
|
}
|
|
|
|
free(subposns);
|
|
|
|
free(src);
|
|
|
|
} while (1);
|
2005-04-19 18:16:12 +00:00
|
|
|
}
|
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
static void reject_merge(struct cache_entry *ce)
|
2005-04-16 16:11:49 +00:00
|
|
|
{
|
2005-09-05 06:04:48 +00:00
|
|
|
die("Entry '%s' would be overwritten by merge. Cannot merge.",
|
|
|
|
ce->name);
|
2005-04-16 16:11:49 +00:00
|
|
|
}
|
|
|
|
|
2005-10-11 00:34:08 +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.
|
|
|
|
*/
|
|
|
|
static void unlink_entry(char *name)
|
|
|
|
{
|
|
|
|
char *cp, *prev;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-23 03:02:39 +00:00
|
|
|
static void progress_interval(int signum)
|
|
|
|
{
|
|
|
|
progress_update = 1;
|
|
|
|
}
|
|
|
|
|
2006-04-02 22:29:34 +00:00
|
|
|
static void setup_progress_signal(void)
|
|
|
|
{
|
|
|
|
struct sigaction sa;
|
|
|
|
struct itimerval v;
|
|
|
|
|
|
|
|
memset(&sa, 0, sizeof(sa));
|
|
|
|
sa.sa_handler = progress_interval;
|
|
|
|
sigemptyset(&sa.sa_mask);
|
|
|
|
sa.sa_flags = SA_RESTART;
|
|
|
|
sigaction(SIGALRM, &sa, NULL);
|
|
|
|
|
|
|
|
v.it_interval.tv_sec = 1;
|
|
|
|
v.it_interval.tv_usec = 0;
|
|
|
|
v.it_value = v.it_interval;
|
|
|
|
setitimer(ITIMER_REAL, &v, NULL);
|
|
|
|
}
|
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
static void check_updates(struct cache_entry **src, int nr)
|
|
|
|
{
|
|
|
|
static struct checkout state = {
|
|
|
|
.base_dir = "",
|
|
|
|
.force = 1,
|
|
|
|
.quiet = 1,
|
|
|
|
.refresh_cache = 1,
|
|
|
|
};
|
|
|
|
unsigned short mask = htons(CE_UPDATE);
|
2006-02-23 03:02:39 +00:00
|
|
|
unsigned last_percent = 200, cnt = 0, total = 0;
|
|
|
|
|
|
|
|
if (update && verbose_update) {
|
|
|
|
for (total = cnt = 0; cnt < nr; cnt++) {
|
|
|
|
struct cache_entry *ce = src[cnt];
|
|
|
|
if (!ce->ce_mode || ce->ce_flags & mask)
|
|
|
|
total++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Don't bother doing this for very small updates */
|
|
|
|
if (total < 250)
|
|
|
|
total = 0;
|
|
|
|
|
|
|
|
if (total) {
|
|
|
|
fprintf(stderr, "Checking files out...\n");
|
2006-04-02 22:29:34 +00:00
|
|
|
setup_progress_signal();
|
2006-02-23 03:02:39 +00:00
|
|
|
progress_update = 1;
|
|
|
|
}
|
|
|
|
cnt = 0;
|
|
|
|
}
|
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
while (nr--) {
|
|
|
|
struct cache_entry *ce = *src++;
|
2006-02-23 03:02:39 +00:00
|
|
|
|
|
|
|
if (total) {
|
|
|
|
if (!ce->ce_mode || ce->ce_flags & mask) {
|
|
|
|
unsigned percent;
|
|
|
|
cnt++;
|
|
|
|
percent = (cnt * 100) / total;
|
|
|
|
if (percent != last_percent ||
|
|
|
|
progress_update) {
|
|
|
|
fprintf(stderr, "%4u%% (%u/%u) done\r",
|
|
|
|
percent, cnt, total);
|
|
|
|
last_percent = percent;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-09-05 06:04:48 +00:00
|
|
|
if (!ce->ce_mode) {
|
|
|
|
if (update)
|
2005-10-11 00:34:08 +00:00
|
|
|
unlink_entry(ce->name);
|
2005-09-05 06:04:48 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (ce->ce_flags & mask) {
|
|
|
|
ce->ce_flags &= ~mask;
|
|
|
|
if (update)
|
2006-03-05 08:24:15 +00:00
|
|
|
checkout_entry(ce, &state, NULL);
|
2005-09-05 06:04:48 +00:00
|
|
|
}
|
|
|
|
}
|
2006-02-23 03:02:39 +00:00
|
|
|
if (total) {
|
|
|
|
signal(SIGALRM, SIG_IGN);
|
2006-04-02 22:29:34 +00:00
|
|
|
fputc('\n', stderr);
|
2006-02-23 03:02:39 +00:00
|
|
|
}
|
2005-09-05 06:04:48 +00:00
|
|
|
}
|
2005-04-16 16:11:49 +00:00
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
static int unpack_trees(merge_fn_t fn)
|
2005-04-16 05:53:45 +00:00
|
|
|
{
|
2005-09-05 06:04:48 +00:00
|
|
|
int indpos = 0;
|
|
|
|
unsigned len = object_list_length(trees);
|
2005-12-26 20:34:56 +00:00
|
|
|
struct tree_entry_list **posns;
|
2005-09-05 06:04:48 +00:00
|
|
|
int i;
|
|
|
|
struct object_list *posn = trees;
|
|
|
|
merge_size = len;
|
2005-12-26 20:34:56 +00:00
|
|
|
|
|
|
|
if (len) {
|
|
|
|
posns = xmalloc(len * sizeof(struct tree_entry_list *));
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
posns[i] = ((struct tree *) posn->item)->entries;
|
|
|
|
posn = posn->next;
|
|
|
|
}
|
|
|
|
if (unpack_trees_rec(posns, len, "", fn, &indpos))
|
|
|
|
return -1;
|
2005-06-06 21:01:58 +00:00
|
|
|
}
|
2005-09-05 06:04:48 +00:00
|
|
|
|
2005-09-29 15:16:12 +00:00
|
|
|
if (trivial_merges_only && nontrivial_merge)
|
|
|
|
die("Merge requires file-level merging");
|
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
check_updates(active_cache, active_nr);
|
|
|
|
return 0;
|
2005-04-16 05:53:45 +00:00
|
|
|
}
|
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
static int list_tree(unsigned char *sha1)
|
|
|
|
{
|
|
|
|
struct tree *tree = parse_tree_indirect(sha1);
|
|
|
|
if (!tree)
|
|
|
|
return -1;
|
|
|
|
object_list_append(&tree->object, &trees);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
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 &&
|
|
|
|
!memcmp(a->sha1, b->sha1, 20);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-06-06 03:02:31 +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 stat st;
|
|
|
|
|
2005-09-11 00:46:27 +00:00
|
|
|
if (index_only)
|
|
|
|
return;
|
|
|
|
|
2005-06-06 03:02:31 +00:00
|
|
|
if (!lstat(ce->name, &st)) {
|
2006-02-09 05:15:24 +00:00
|
|
|
unsigned changed = ce_match_stat(ce, &st, 1);
|
2005-06-06 03:02:31 +00:00
|
|
|
if (!changed)
|
|
|
|
return;
|
|
|
|
errno = 0;
|
|
|
|
}
|
|
|
|
if (errno == ENOENT)
|
|
|
|
return;
|
|
|
|
die("Entry '%s' not uptodate. Cannot merge.", ce->name);
|
|
|
|
}
|
|
|
|
|
2006-04-27 07:13:34 +00:00
|
|
|
static void invalidate_ce_path(struct cache_entry *ce)
|
|
|
|
{
|
|
|
|
if (ce)
|
|
|
|
cache_tree_invalidate_path(active_cache_tree, ce->name);
|
|
|
|
}
|
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
static int merged_entry(struct cache_entry *merge, struct cache_entry *old)
|
2005-04-16 05:53:45 +00:00
|
|
|
{
|
2005-06-06 21:01:58 +00:00
|
|
|
merge->ce_flags |= htons(CE_UPDATE);
|
|
|
|
if (old) {
|
2005-06-06 03:02:31 +00:00
|
|
|
/*
|
2005-06-06 21:01:58 +00:00
|
|
|
* 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.
|
2005-06-06 03:02:31 +00:00
|
|
|
*/
|
2005-06-06 21:01:58 +00:00
|
|
|
if (same(old, merge)) {
|
|
|
|
*merge = *old;
|
2005-09-05 06:04:48 +00:00
|
|
|
} else {
|
2005-06-06 21:01:58 +00:00
|
|
|
verify_uptodate(old);
|
2006-04-27 07:13:34 +00:00
|
|
|
invalidate_ce_path(old);
|
2005-06-06 21:01:58 +00:00
|
|
|
}
|
2005-04-19 18:41:18 +00:00
|
|
|
}
|
2006-05-03 23:07:02 +00:00
|
|
|
else
|
|
|
|
invalidate_ce_path(merge);
|
2005-06-06 21:01:58 +00:00
|
|
|
merge->ce_flags &= ~htons(CE_STAGEMASK);
|
2005-09-05 06:04:48 +00:00
|
|
|
add_cache_entry(merge, ADD_CACHE_OK_TO_ADD);
|
2005-06-06 21:01:58 +00:00
|
|
|
return 1;
|
2005-04-19 18:41:18 +00:00
|
|
|
}
|
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
static int deleted_entry(struct cache_entry *ce, struct cache_entry *old)
|
2005-06-09 22:34:04 +00:00
|
|
|
{
|
|
|
|
if (old)
|
|
|
|
verify_uptodate(old);
|
|
|
|
ce->ce_mode = 0;
|
2005-09-05 06:04:48 +00:00
|
|
|
add_cache_entry(ce, ADD_CACHE_OK_TO_ADD);
|
2006-04-27 07:13:34 +00:00
|
|
|
invalidate_ce_path(ce);
|
2005-06-09 22:34:04 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
static int keep_entry(struct cache_entry *ce)
|
2005-06-11 09:50:51 +00:00
|
|
|
{
|
2005-09-05 06:04:48 +00:00
|
|
|
add_cache_entry(ce, ADD_CACHE_OK_TO_ADD);
|
|
|
|
return 1;
|
2005-06-11 09:50:51 +00:00
|
|
|
}
|
|
|
|
|
2005-09-06 19:53:56 +00:00
|
|
|
#if DBRT_DEBUG
|
|
|
|
static void show_stage_entry(FILE *o,
|
|
|
|
const char *label, const struct cache_entry *ce)
|
|
|
|
{
|
2005-09-14 05:27:42 +00:00
|
|
|
if (!ce)
|
|
|
|
fprintf(o, "%s (missing)\n", label);
|
|
|
|
else
|
|
|
|
fprintf(o, "%s%06o %s %d\t%s\n",
|
|
|
|
label,
|
|
|
|
ntohl(ce->ce_mode),
|
|
|
|
sha1_to_hex(ce->sha1),
|
|
|
|
ce_stage(ce),
|
|
|
|
ce->name);
|
2005-09-06 19:53:56 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
static int threeway_merge(struct cache_entry **stages)
|
2005-06-06 05:59:59 +00:00
|
|
|
{
|
2005-09-05 06:04:48 +00:00
|
|
|
struct cache_entry *index;
|
|
|
|
struct cache_entry *head;
|
|
|
|
struct cache_entry *remote = stages[head_idx + 1];
|
2005-06-06 21:01:58 +00:00
|
|
|
int count;
|
2005-09-05 06:04:48 +00:00
|
|
|
int head_match = 0;
|
|
|
|
int remote_match = 0;
|
2005-06-06 21:01:58 +00:00
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
int df_conflict_head = 0;
|
|
|
|
int df_conflict_remote = 0;
|
|
|
|
|
|
|
|
int any_anc_missing = 0;
|
2006-02-04 06:04:14 +00:00
|
|
|
int no_anc_exists = 1;
|
2005-09-05 06:04:48 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 1; i < head_idx; i++) {
|
|
|
|
if (!stages[i])
|
|
|
|
any_anc_missing = 1;
|
2006-02-04 06:04:14 +00:00
|
|
|
else
|
|
|
|
no_anc_exists = 0;
|
[PATCH] read-tree: fix too strong index requirement #5ALT
This fixes too strong index requirement 3-way merge enforces in
one case: the same file is added in both branches.
In this case, the original code insisted that if the index file
has that path, it must match our branch and be up-to-date.
However in this particular case, it only has to match it, and
can be dirty. We just need to make sure that we keep the
work-tree copy instead of checking out the merge result.
The resolution of such a path, however, cannot be left to
outside script, because we will not keep the original stage0
entries for unmerged paths when read-tree finishes, and at that
point, the knowledge of "if we resolve it to match the new file
added in both branches, the merge succeeds and the work tree
would not lose information, but we should _not_ update the work
tree from the resulting index file" is lost. For this reason,
the now code needs to resolve this case (#5ALT) internally.
This affects some existing tests in the test suite, but all in
positive ways. In t1000 (3-way test), this #5ALT case now gets
one stage0 entry, instead of an identical stage2 and stage3
entry pair, for such a path, and one test that checked for merge
failure (because the test assumed the "stricter-than-necessary"
behaviour) does not have to fail anymore. In t1005 (emu23
test), two tests that involves a case where the work tree
already had a change introduced in the upstream (aka "merged
head"), the merge succeeds instead of failing.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-11 01:37:47 +00:00
|
|
|
}
|
2005-09-05 06:04:48 +00:00
|
|
|
|
|
|
|
index = stages[0];
|
|
|
|
head = stages[head_idx];
|
|
|
|
|
|
|
|
if (head == &df_conflict_entry) {
|
|
|
|
df_conflict_head = 1;
|
|
|
|
head = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (remote == &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 < head_idx; i++) {
|
|
|
|
if (same(stages[i], head)) {
|
2005-09-06 19:53:56 +00:00
|
|
|
head_match = i;
|
2005-09-05 06:04:48 +00:00
|
|
|
}
|
|
|
|
if (same(stages[i], remote)) {
|
2005-09-06 19:53:56 +00:00
|
|
|
remote_match = i;
|
2005-09-05 06:04:48 +00:00
|
|
|
}
|
2005-06-11 09:50:51 +00:00
|
|
|
}
|
|
|
|
}
|
2005-09-05 06:04:48 +00:00
|
|
|
|
|
|
|
/* 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);
|
2005-06-11 09:53:57 +00:00
|
|
|
}
|
2005-06-06 21:01:58 +00:00
|
|
|
/*
|
2005-09-05 06:04:48 +00:00
|
|
|
* If we have an entry in the index cache, then we want to
|
|
|
|
* make sure that it matches head.
|
2005-06-06 21:01:58 +00:00
|
|
|
*/
|
2005-09-05 06:04:48 +00:00
|
|
|
if (index && !same(index, head)) {
|
|
|
|
reject_merge(index);
|
2005-06-06 05:59:59 +00:00
|
|
|
}
|
2005-09-05 06:04:48 +00:00
|
|
|
|
|
|
|
if (head) {
|
|
|
|
/* #5ALT, #15 */
|
|
|
|
if (same(head, remote))
|
|
|
|
return merged_entry(head, index);
|
|
|
|
/* #13, #3ALT */
|
|
|
|
if (!df_conflict_remote && remote_match && !head_match)
|
|
|
|
return merged_entry(head, index);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* #1 */
|
|
|
|
if (!head && !remote && any_anc_missing)
|
|
|
|
return 0;
|
|
|
|
|
2006-02-04 06:04:14 +00:00
|
|
|
/* Under the new "aggressive" rule, we resolve mostly trivial
|
|
|
|
* cases that we historically had git-merge-one-file resolve.
|
|
|
|
*/
|
|
|
|
if (aggressive) {
|
|
|
|
int head_deleted = !head && !df_conflict_head;
|
|
|
|
int remote_deleted = !remote && !df_conflict_remote;
|
|
|
|
/*
|
|
|
|
* Deleted in both.
|
|
|
|
* Deleted in one and unchanged in the other.
|
|
|
|
*/
|
|
|
|
if ((head_deleted && remote_deleted) ||
|
|
|
|
(head_deleted && remote && remote_match) ||
|
2006-03-02 07:10:00 +00:00
|
|
|
(remote_deleted && head && head_match)) {
|
|
|
|
if (index)
|
|
|
|
return deleted_entry(index, index);
|
2006-02-04 06:04:14 +00:00
|
|
|
return 0;
|
2006-03-02 07:10:00 +00:00
|
|
|
}
|
2006-02-04 06:04:14 +00:00
|
|
|
/*
|
|
|
|
* Added in both, identically.
|
|
|
|
*/
|
|
|
|
if (no_anc_exists && head && remote && same(head, remote))
|
|
|
|
return merged_entry(head, index);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
/* 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);
|
|
|
|
}
|
|
|
|
|
2005-09-29 15:16:12 +00:00
|
|
|
nontrivial_merge = 1;
|
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
/* #2, #3, #4, #6, #7, #9, #11. */
|
2005-06-06 21:01:58 +00:00
|
|
|
count = 0;
|
2005-09-05 06:04:48 +00:00
|
|
|
if (!head_match || !remote_match) {
|
|
|
|
for (i = 1; i < head_idx; i++) {
|
|
|
|
if (stages[i]) {
|
|
|
|
keep_entry(stages[i]);
|
|
|
|
count++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-09-06 19:53:56 +00:00
|
|
|
#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
|
2005-09-05 06:04:48 +00:00
|
|
|
if (head) { count += keep_entry(head); }
|
|
|
|
if (remote) { count += keep_entry(remote); }
|
2005-06-06 21:01:58 +00:00
|
|
|
return count;
|
2005-06-06 05:59:59 +00:00
|
|
|
}
|
|
|
|
|
2005-06-06 05:07:31 +00:00
|
|
|
/*
|
|
|
|
* Two-way merge.
|
|
|
|
*
|
2005-06-07 18:36:30 +00:00
|
|
|
* 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>.
|
|
|
|
*
|
2005-06-06 05:07:31 +00:00
|
|
|
*/
|
2005-09-05 06:04:48 +00:00
|
|
|
static int twoway_merge(struct cache_entry **src)
|
2005-04-19 18:41:18 +00:00
|
|
|
{
|
2005-06-07 18:36:30 +00:00
|
|
|
struct cache_entry *current = src[0];
|
|
|
|
struct cache_entry *oldtree = src[1], *newtree = src[2];
|
2005-06-06 05:07:31 +00:00
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
if (merge_size != 2)
|
2006-02-23 01:47:10 +00:00
|
|
|
return error("Cannot do a twoway merge of %d trees",
|
2005-09-05 06:04:48 +00:00
|
|
|
merge_size);
|
2005-06-06 05:59:59 +00:00
|
|
|
|
2005-06-07 18:36:30 +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 &&
|
|
|
|
!same(oldtree, newtree) && /* 18 and 19*/
|
|
|
|
same(current, newtree))) {
|
2005-09-05 06:04:48 +00:00
|
|
|
return keep_entry(current);
|
2005-06-07 18:36:30 +00:00
|
|
|
}
|
|
|
|
else if (oldtree && !newtree && same(current, oldtree)) {
|
|
|
|
/* 10 or 11 */
|
2005-09-05 06:04:48 +00:00
|
|
|
return deleted_entry(oldtree, current);
|
2005-06-07 18:36:30 +00:00
|
|
|
}
|
|
|
|
else if (oldtree && newtree &&
|
|
|
|
same(current, oldtree) && !same(current, newtree)) {
|
|
|
|
/* 20 or 21 */
|
2005-09-05 06:04:48 +00:00
|
|
|
return merged_entry(newtree, current);
|
2005-06-07 18:36:30 +00:00
|
|
|
}
|
2005-09-05 06:04:48 +00:00
|
|
|
else {
|
2005-06-07 18:36:30 +00:00
|
|
|
/* all other failures */
|
2005-09-05 06:04:48 +00:00
|
|
|
if (oldtree)
|
|
|
|
reject_merge(oldtree);
|
|
|
|
if (current)
|
|
|
|
reject_merge(current);
|
|
|
|
if (newtree)
|
|
|
|
reject_merge(newtree);
|
2005-06-06 21:01:58 +00:00
|
|
|
return -1;
|
2005-09-05 06:04:48 +00:00
|
|
|
}
|
2005-06-06 05:59:59 +00:00
|
|
|
}
|
2005-06-07 18:36:30 +00:00
|
|
|
else if (newtree)
|
2005-09-05 06:04:48 +00:00
|
|
|
return merged_entry(newtree, current);
|
2005-06-07 18:36:30 +00:00
|
|
|
else
|
2005-09-05 06:04:48 +00:00
|
|
|
return deleted_entry(oldtree, current);
|
2005-06-11 01:36:08 +00:00
|
|
|
}
|
|
|
|
|
2005-06-06 21:01:58 +00:00
|
|
|
/*
|
|
|
|
* One-way merge.
|
|
|
|
*
|
|
|
|
* The rule is:
|
|
|
|
* - take the stat information from stage0, take the data from stage1
|
|
|
|
*/
|
2005-09-05 06:04:48 +00:00
|
|
|
static int oneway_merge(struct cache_entry **src)
|
2005-06-06 05:07:31 +00:00
|
|
|
{
|
2005-06-06 21:01:58 +00:00
|
|
|
struct cache_entry *old = src[0];
|
|
|
|
struct cache_entry *a = src[1];
|
2005-04-19 18:41:18 +00:00
|
|
|
|
2005-09-05 06:04:48 +00:00
|
|
|
if (merge_size != 1)
|
2006-02-23 01:47:10 +00:00
|
|
|
return error("Cannot do a oneway merge of %d trees",
|
2005-09-05 06:04:48 +00:00
|
|
|
merge_size);
|
2005-04-19 18:41:18 +00:00
|
|
|
|
2006-04-27 07:13:34 +00:00
|
|
|
if (!a) {
|
|
|
|
invalidate_ce_path(old);
|
2005-06-06 21:01:58 +00:00
|
|
|
return 0;
|
2006-04-27 07:13:34 +00:00
|
|
|
}
|
2005-06-07 22:17:33 +00:00
|
|
|
if (old && same(old, a)) {
|
2005-09-05 06:04:48 +00:00
|
|
|
return keep_entry(old);
|
2005-06-07 22:17:33 +00:00
|
|
|
}
|
2005-09-05 06:04:48 +00:00
|
|
|
return merged_entry(a, NULL);
|
2005-06-06 21:01:58 +00:00
|
|
|
}
|
|
|
|
|
2005-06-09 19:51:01 +00:00
|
|
|
static int read_cache_unmerged(void)
|
|
|
|
{
|
|
|
|
int i, deleted;
|
|
|
|
struct cache_entry **dst;
|
|
|
|
|
|
|
|
read_cache();
|
|
|
|
dst = active_cache;
|
|
|
|
deleted = 0;
|
|
|
|
for (i = 0; i < active_nr; i++) {
|
|
|
|
struct cache_entry *ce = active_cache[i];
|
|
|
|
if (ce_stage(ce)) {
|
|
|
|
deleted++;
|
2006-04-27 07:13:34 +00:00
|
|
|
invalidate_ce_path(ce);
|
2005-06-09 19:51:01 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (deleted)
|
|
|
|
*dst = ce;
|
|
|
|
dst++;
|
|
|
|
}
|
|
|
|
active_nr -= deleted;
|
|
|
|
return deleted;
|
|
|
|
}
|
|
|
|
|
2006-04-27 08:33:07 +00:00
|
|
|
static void prime_cache_tree_rec(struct cache_tree *it, struct tree *tree)
|
|
|
|
{
|
|
|
|
struct tree_entry_list *ent;
|
|
|
|
int cnt;
|
|
|
|
|
|
|
|
memcpy(it->sha1, tree->object.sha1, 20);
|
|
|
|
for (cnt = 0, ent = tree->entries; ent; ent = ent->next) {
|
|
|
|
if (!ent->directory)
|
|
|
|
cnt++;
|
|
|
|
else {
|
|
|
|
struct cache_tree_sub *sub;
|
|
|
|
struct tree *subtree = (struct tree *)ent->item.tree;
|
|
|
|
if (!subtree->object.parsed)
|
|
|
|
parse_tree(subtree);
|
|
|
|
sub = cache_tree_sub(it, ent->name);
|
|
|
|
sub->cache_tree = cache_tree();
|
|
|
|
prime_cache_tree_rec(sub->cache_tree, subtree);
|
|
|
|
cnt += sub->cache_tree->entry_count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
it->entry_count = cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void prime_cache_tree(void)
|
|
|
|
{
|
|
|
|
struct tree *tree = (struct tree *)trees->item;
|
|
|
|
if (!tree)
|
|
|
|
return;
|
|
|
|
active_cache_tree = cache_tree();
|
|
|
|
prime_cache_tree_rec(active_cache_tree, tree);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2006-03-02 09:11:05 +00:00
|
|
|
static const char read_tree_usage[] = "git-read-tree (<sha> | -m [--aggressive] [-u | -i] <sha1> [<sha2> [<sha3>]])";
|
2005-04-21 02:49:16 +00:00
|
|
|
|
2005-06-06 19:20:55 +00:00
|
|
|
static struct cache_file cache_file;
|
|
|
|
|
2005-04-07 22:13:13 +00:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
2005-09-05 06:04:48 +00:00
|
|
|
int i, newfd, reset, stage = 0;
|
2005-04-07 22:13:13 +00:00
|
|
|
unsigned char sha1[20];
|
2005-09-05 06:04:48 +00:00
|
|
|
merge_fn_t fn = NULL;
|
2005-04-21 17:55:18 +00:00
|
|
|
|
2005-11-26 08:50:02 +00:00
|
|
|
setup_git_directory();
|
2006-03-24 07:41:18 +00:00
|
|
|
git_config(git_default_config);
|
2005-11-26 08:50:02 +00:00
|
|
|
|
2005-06-06 19:20:55 +00:00
|
|
|
newfd = hold_index_file_for_update(&cache_file, get_index_file());
|
2005-04-09 19:11:25 +00:00
|
|
|
if (newfd < 0)
|
2005-04-13 09:28:48 +00:00
|
|
|
die("unable to create new cachefile");
|
2005-04-09 19:11:25 +00:00
|
|
|
|
2005-11-08 08:23:37 +00:00
|
|
|
git_config(git_default_config);
|
|
|
|
|
2005-04-19 18:16:12 +00:00
|
|
|
merge = 0;
|
2005-06-09 19:51:01 +00:00
|
|
|
reset = 0;
|
2005-04-09 19:11:25 +00:00
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
const char *arg = argv[i];
|
|
|
|
|
2005-09-11 00:46:27 +00:00
|
|
|
/* "-u" means "update", meaning that a merge will update
|
|
|
|
* the working tree.
|
|
|
|
*/
|
2005-06-06 05:07:31 +00:00
|
|
|
if (!strcmp(arg, "-u")) {
|
|
|
|
update = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2006-02-23 03:02:39 +00:00
|
|
|
if (!strcmp(arg, "-v")) {
|
|
|
|
verbose_update = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-09-11 00:46:27 +00:00
|
|
|
/* "-i" means "index only", meaning that a merge will
|
|
|
|
* not even look at the working tree.
|
|
|
|
*/
|
|
|
|
if (!strcmp(arg, "-i")) {
|
|
|
|
index_only = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-06-09 19:51:01 +00:00
|
|
|
/* This differs from "-m" in that we'll silently ignore unmerged entries */
|
|
|
|
if (!strcmp(arg, "--reset")) {
|
2005-09-05 06:04:48 +00:00
|
|
|
if (stage || merge)
|
2005-06-09 19:51:01 +00:00
|
|
|
usage(read_tree_usage);
|
|
|
|
reset = 1;
|
|
|
|
merge = 1;
|
|
|
|
stage = 1;
|
|
|
|
read_cache_unmerged();
|
2005-06-15 17:25:46 +00:00
|
|
|
continue;
|
2005-06-09 19:51:01 +00:00
|
|
|
}
|
|
|
|
|
2005-09-29 15:16:12 +00:00
|
|
|
if (!strcmp(arg, "--trivial")) {
|
|
|
|
trivial_merges_only = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2006-02-04 06:04:14 +00:00
|
|
|
if (!strcmp(arg, "--aggressive")) {
|
|
|
|
aggressive = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-04-16 05:53:45 +00:00
|
|
|
/* "-m" stands for "merge", meaning we start in stage 1 */
|
2005-04-09 19:11:25 +00:00
|
|
|
if (!strcmp(arg, "-m")) {
|
2005-09-05 06:04:48 +00:00
|
|
|
if (stage || merge)
|
2005-06-09 19:51:01 +00:00
|
|
|
usage(read_tree_usage);
|
|
|
|
if (read_cache_unmerged())
|
|
|
|
die("you need to resolve your current index first");
|
2005-04-16 05:53:45 +00:00
|
|
|
stage = 1;
|
2005-04-19 18:16:12 +00:00
|
|
|
merge = 1;
|
2005-04-09 19:11:25 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-06-11 01:36:08 +00:00
|
|
|
|
2005-09-11 00:46:27 +00:00
|
|
|
/* using -u and -i at the same time makes no sense */
|
|
|
|
if (1 < index_only + update)
|
|
|
|
usage(read_tree_usage);
|
|
|
|
|
2005-05-01 23:36:56 +00:00
|
|
|
if (get_sha1(arg, sha1) < 0)
|
2005-04-21 02:49:16 +00:00
|
|
|
usage(read_tree_usage);
|
2005-09-05 06:04:48 +00:00
|
|
|
if (list_tree(sha1) < 0)
|
2005-04-13 09:28:48 +00:00
|
|
|
die("failed to unpack tree object %s", arg);
|
2005-04-16 05:53:45 +00:00
|
|
|
stage++;
|
2005-04-09 19:11:25 +00:00
|
|
|
}
|
2005-09-19 18:33:14 +00:00
|
|
|
if ((update||index_only) && !merge)
|
2005-06-07 22:20:39 +00:00
|
|
|
usage(read_tree_usage);
|
2005-10-02 07:50:16 +00:00
|
|
|
|
|
|
|
if (merge) {
|
2005-09-05 06:04:48 +00:00
|
|
|
if (stage < 2)
|
2005-04-19 18:41:18 +00:00
|
|
|
die("just how do you expect me to merge %d trees?", stage-1);
|
2005-09-05 06:04:48 +00:00
|
|
|
switch (stage - 1) {
|
|
|
|
case 1:
|
|
|
|
fn = oneway_merge;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
fn = twoway_merge;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
default:
|
|
|
|
fn = threeway_merge;
|
2006-04-27 07:13:34 +00:00
|
|
|
cache_tree_free(&active_cache_tree);
|
2005-09-05 06:04:48 +00:00
|
|
|
break;
|
2005-06-11 01:36:08 +00:00
|
|
|
}
|
2005-09-05 06:04:48 +00:00
|
|
|
|
|
|
|
if (stage - 1 >= 3)
|
|
|
|
head_idx = stage - 2;
|
|
|
|
else
|
|
|
|
head_idx = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
unpack_trees(fn);
|
2006-04-27 08:33:07 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* When reading only one tree (either the most basic form,
|
|
|
|
* "-m ent" or "--reset ent" form), we can obtain a fully
|
|
|
|
* valid cache-tree because the index must match exactly
|
|
|
|
* what came from the tree.
|
|
|
|
*/
|
|
|
|
if (trees->item && (!merge || (stage == 2))) {
|
|
|
|
cache_tree_free(&active_cache_tree);
|
|
|
|
prime_cache_tree();
|
|
|
|
}
|
|
|
|
|
2005-06-06 19:20:55 +00:00
|
|
|
if (write_cache(newfd, active_cache, active_nr) ||
|
|
|
|
commit_index_file(&cache_file))
|
2005-04-13 09:28:48 +00:00
|
|
|
die("unable to write new index file");
|
2005-04-11 22:39:26 +00:00
|
|
|
return 0;
|
2005-04-07 22:13:13 +00:00
|
|
|
}
|