2005-04-08 00:16:10 +02:00
|
|
|
/*
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
*
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
*/
|
2005-04-08 00:13:13 +02:00
|
|
|
#include "cache.h"
|
|
|
|
|
2005-04-16 07:53:45 +02:00
|
|
|
static int stage = 0;
|
2005-06-06 07:07:31 +02:00
|
|
|
static int update = 0;
|
2005-04-16 07:53:45 +02:00
|
|
|
|
2005-04-23 01:42:37 +02:00
|
|
|
static int unpack_tree(unsigned char *sha1)
|
2005-04-21 03:06:50 +02:00
|
|
|
{
|
|
|
|
void *buffer;
|
|
|
|
unsigned long size;
|
2005-05-11 23:16:23 +02:00
|
|
|
int ret;
|
2005-04-21 03:06:50 +02:00
|
|
|
|
2005-05-20 20:46:10 +02:00
|
|
|
buffer = read_object_with_reference(sha1, "tree", &size, NULL);
|
2005-04-23 01:35:06 +02:00
|
|
|
if (!buffer)
|
|
|
|
return -1;
|
2005-05-11 23:16:23 +02:00
|
|
|
ret = read_tree(buffer, size, stage);
|
|
|
|
free(buffer);
|
|
|
|
return ret;
|
2005-04-21 03:06:50 +02:00
|
|
|
}
|
|
|
|
|
2005-04-19 20:16:12 +02:00
|
|
|
static int path_matches(struct cache_entry *a, struct cache_entry *b)
|
|
|
|
{
|
|
|
|
int len = ce_namelen(a);
|
|
|
|
return ce_namelen(b) == len &&
|
|
|
|
!memcmp(a->name, b->name, len);
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:11:49 +02:00
|
|
|
static int same(struct cache_entry *a, struct cache_entry *b)
|
|
|
|
{
|
|
|
|
return a->ce_mode == b->ce_mode &&
|
|
|
|
!memcmp(a->sha1, b->sha1, 20);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-16 07:53:45 +02:00
|
|
|
/*
|
2005-04-16 18:11:49 +02:00
|
|
|
* This removes all trivial merges that don't change the tree
|
|
|
|
* and collapses them to state 0.
|
2005-04-16 07:53:45 +02:00
|
|
|
*
|
2005-04-16 18:11:49 +02:00
|
|
|
* _Any_ other merge is left to user policy. That includes "both
|
|
|
|
* created the same file", and "both removed the same file" - which are
|
|
|
|
* trivial, but the user might still want to _note_ it.
|
2005-04-16 07:53:45 +02:00
|
|
|
*/
|
2005-04-16 18:11:49 +02:00
|
|
|
static struct cache_entry *merge_entries(struct cache_entry *a,
|
|
|
|
struct cache_entry *b,
|
|
|
|
struct cache_entry *c)
|
2005-04-16 07:53:45 +02:00
|
|
|
{
|
|
|
|
int len = ce_namelen(a);
|
2005-04-16 18:11:49 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Are they all the same filename? We won't do
|
|
|
|
* any name merging
|
|
|
|
*/
|
|
|
|
if (ce_namelen(b) != len ||
|
|
|
|
ce_namelen(c) != len ||
|
|
|
|
memcmp(a->name, b->name, len) ||
|
|
|
|
memcmp(a->name, c->name, len))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ok, all three entries describe the same
|
|
|
|
* filename, but maybe the contents or file
|
|
|
|
* mode have changed?
|
|
|
|
*
|
|
|
|
* The trivial cases end up being the ones where two
|
|
|
|
* out of three files are the same:
|
|
|
|
* - both destinations the same, trivially take either
|
|
|
|
* - one of the destination versions hasn't changed,
|
|
|
|
* take the other.
|
|
|
|
*
|
|
|
|
* The "all entries exactly the same" case falls out as
|
|
|
|
* a special case of any of the "two same" cases.
|
|
|
|
*
|
|
|
|
* Here "a" is "original", and "b" and "c" are the two
|
|
|
|
* trees we are merging.
|
|
|
|
*/
|
|
|
|
if (same(b,c))
|
|
|
|
return c;
|
|
|
|
if (same(a,b))
|
|
|
|
return c;
|
|
|
|
if (same(a,c))
|
|
|
|
return b;
|
|
|
|
return NULL;
|
2005-04-16 07:53:45 +02:00
|
|
|
}
|
|
|
|
|
2005-06-06 05:02:31 +02: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;
|
|
|
|
|
|
|
|
if (!lstat(ce->name, &st)) {
|
|
|
|
unsigned changed = ce_match_stat(ce, &st);
|
|
|
|
if (!changed)
|
|
|
|
return;
|
|
|
|
errno = 0;
|
|
|
|
}
|
|
|
|
if (errno == ENOENT)
|
|
|
|
return;
|
|
|
|
die("Entry '%s' not uptodate. Cannot merge.", ce->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the old tree contained a CE that isn't even in the
|
|
|
|
* result, that's always a problem, regardless of whether
|
|
|
|
* it's up-to-date or not (ie it can be a file that we
|
|
|
|
* have updated but not committed yet).
|
|
|
|
*/
|
2005-06-06 05:28:33 +02:00
|
|
|
static void reject_merge(struct cache_entry *ce)
|
2005-06-06 05:02:31 +02:00
|
|
|
{
|
2005-06-06 05:28:33 +02:00
|
|
|
die("Entry '%s' would be overwritten by merge. Cannot merge.", ce->name);
|
2005-06-06 05:02:31 +02:00
|
|
|
}
|
|
|
|
|
2005-06-06 05:28:33 +02:00
|
|
|
#define CHECK_OLD(ce) if (old && same(old, ce)) { verify_uptodate(old); old = NULL; }
|
2005-06-06 05:02:31 +02:00
|
|
|
|
2005-04-16 07:53:45 +02:00
|
|
|
static void trivially_merge_cache(struct cache_entry **src, int nr)
|
|
|
|
{
|
|
|
|
struct cache_entry **dst = src;
|
2005-06-06 05:02:31 +02:00
|
|
|
struct cache_entry *old = NULL;
|
2005-04-16 07:53:45 +02:00
|
|
|
|
2005-06-06 07:07:31 +02:00
|
|
|
while (nr--) {
|
2005-04-16 18:11:49 +02:00
|
|
|
struct cache_entry *ce, *result;
|
2005-04-16 07:53:45 +02:00
|
|
|
|
2005-06-06 07:07:31 +02:00
|
|
|
ce = *src++;
|
2005-04-19 20:16:12 +02:00
|
|
|
|
|
|
|
/* We throw away original cache entries except for the stat information */
|
|
|
|
if (!ce_stage(ce)) {
|
2005-06-06 05:28:33 +02:00
|
|
|
if (old)
|
|
|
|
reject_merge(old);
|
2005-04-19 20:16:12 +02:00
|
|
|
old = ce;
|
|
|
|
active_nr--;
|
|
|
|
continue;
|
|
|
|
}
|
2005-06-06 05:28:33 +02:00
|
|
|
if (old && !path_matches(old, ce))
|
|
|
|
reject_merge(old);
|
2005-06-06 08:38:18 +02:00
|
|
|
if (nr > 1 && (result = merge_entries(ce, src[0], src[1])) != NULL) {
|
2005-06-06 07:07:31 +02:00
|
|
|
result->ce_flags |= htons(CE_UPDATE);
|
2005-04-19 20:16:12 +02:00
|
|
|
/*
|
|
|
|
* See if we can re-use the old CE directly?
|
|
|
|
* That way we get the uptodate stat info.
|
2005-06-06 07:07:31 +02:00
|
|
|
*
|
|
|
|
* This also removes the UPDATE flag on
|
|
|
|
* a match.
|
2005-04-19 20:16:12 +02:00
|
|
|
*/
|
2005-06-06 05:28:33 +02:00
|
|
|
if (old && same(old, result)) {
|
2005-04-19 20:16:12 +02:00
|
|
|
*result = *old;
|
2005-06-06 05:02:31 +02:00
|
|
|
old = NULL;
|
|
|
|
}
|
2005-06-06 05:28:33 +02:00
|
|
|
CHECK_OLD(ce);
|
2005-06-06 08:32:53 +02:00
|
|
|
CHECK_OLD(src[0]);
|
2005-06-06 05:28:33 +02:00
|
|
|
CHECK_OLD(src[1]);
|
2005-04-16 18:11:49 +02:00
|
|
|
ce = result;
|
2005-04-16 07:53:45 +02:00
|
|
|
ce->ce_flags &= ~htons(CE_STAGEMASK);
|
|
|
|
src += 2;
|
|
|
|
nr -= 2;
|
|
|
|
active_nr -= 2;
|
|
|
|
}
|
2005-06-06 05:02:31 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we had an old entry that we now effectively
|
|
|
|
* overwrite, make sure it wasn't dirty.
|
|
|
|
*/
|
2005-06-06 05:28:33 +02:00
|
|
|
CHECK_OLD(ce);
|
2005-04-19 20:41:18 +02:00
|
|
|
*dst++ = ce;
|
|
|
|
}
|
2005-06-06 05:28:33 +02:00
|
|
|
if (old)
|
|
|
|
reject_merge(old);
|
2005-04-19 20:41:18 +02:00
|
|
|
}
|
|
|
|
|
2005-06-06 07:59:59 +02:00
|
|
|
/*
|
|
|
|
* When we find a "stage2" entry in the two-way merge, that's
|
|
|
|
* the one that will remain. If we have an exact old match,
|
|
|
|
* we don't care whether the file is up-to-date or not, we just
|
|
|
|
* re-use the thing directly.
|
|
|
|
*
|
|
|
|
* If we didn't have an exact match, then we want to make sure
|
|
|
|
* that we've seen a stage1 that matched the old, and that the
|
|
|
|
* old file was up-to-date. Because it will be gone after this
|
|
|
|
* merge..
|
|
|
|
*/
|
|
|
|
static void twoway_check(struct cache_entry *old, int seen_stage1, struct cache_entry *ce)
|
|
|
|
{
|
|
|
|
if (path_matches(old, ce)) {
|
|
|
|
/*
|
|
|
|
* This also removes the UPDATE flag on
|
|
|
|
* a match
|
|
|
|
*/
|
|
|
|
if (same(old, ce)) {
|
|
|
|
*ce = *old;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!seen_stage1)
|
|
|
|
reject_merge(old);
|
|
|
|
}
|
|
|
|
verify_uptodate(old);
|
|
|
|
}
|
|
|
|
|
2005-06-06 07:07:31 +02:00
|
|
|
/*
|
|
|
|
* Two-way merge.
|
|
|
|
*
|
|
|
|
* The rule is:
|
|
|
|
* - every current entry has to match the old tree
|
|
|
|
* - if the current entry matches the new tree, we leave it
|
|
|
|
* as-is. Otherwise we require that it be up-to-date.
|
|
|
|
*/
|
|
|
|
static void twoway_merge(struct cache_entry **src, int nr)
|
2005-04-19 20:41:18 +02:00
|
|
|
{
|
2005-06-06 07:59:59 +02:00
|
|
|
int seen_stage1 = 0;
|
|
|
|
struct cache_entry *old = NULL;
|
2005-04-19 20:41:18 +02:00
|
|
|
struct cache_entry **dst = src;
|
|
|
|
|
2005-06-06 07:07:31 +02:00
|
|
|
while (nr--) {
|
|
|
|
struct cache_entry *ce = *src++;
|
|
|
|
int stage = ce_stage(ce);
|
|
|
|
|
|
|
|
switch (stage) {
|
|
|
|
case 0:
|
|
|
|
if (old)
|
|
|
|
reject_merge(old);
|
|
|
|
old = ce;
|
2005-06-06 07:59:59 +02:00
|
|
|
seen_stage1 = 0;
|
2005-06-06 07:07:31 +02:00
|
|
|
active_nr--;
|
|
|
|
continue;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
active_nr--;
|
|
|
|
if (!old)
|
|
|
|
continue;
|
|
|
|
if (!path_matches(old, ce) || !same(old, ce))
|
|
|
|
reject_merge(old);
|
2005-06-06 07:59:59 +02:00
|
|
|
seen_stage1 = 1;
|
2005-06-06 07:07:31 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
ce->ce_flags |= htons(CE_UPDATE);
|
|
|
|
if (old) {
|
2005-06-06 07:59:59 +02:00
|
|
|
twoway_check(old, seen_stage1, ce);
|
2005-06-06 07:07:31 +02:00
|
|
|
old = NULL;
|
|
|
|
}
|
|
|
|
ce->ce_flags &= ~htons(CE_STAGEMASK);
|
|
|
|
*dst++ = ce;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
die("impossible two-way stage");
|
|
|
|
}
|
2005-06-06 07:59:59 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Unmatched with a new entry? Make sure it was
|
|
|
|
* at least uptodate in the working directory _and_
|
|
|
|
* the original tree..
|
|
|
|
*/
|
|
|
|
if (old) {
|
|
|
|
if (!seen_stage1)
|
|
|
|
reject_merge(old);
|
|
|
|
verify_uptodate(old);
|
|
|
|
}
|
2005-06-06 07:07:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void merge_stat_info(struct cache_entry **src, int nr)
|
|
|
|
{
|
|
|
|
static struct cache_entry null_entry;
|
|
|
|
struct cache_entry **dst = src;
|
|
|
|
struct cache_entry *stat = &null_entry;
|
2005-04-19 20:41:18 +02:00
|
|
|
|
2005-06-06 07:07:31 +02:00
|
|
|
while (nr--) {
|
|
|
|
struct cache_entry *ce = *src++;
|
2005-04-19 20:41:18 +02:00
|
|
|
|
|
|
|
/* We throw away original cache entries except for the stat information */
|
|
|
|
if (!ce_stage(ce)) {
|
2005-06-06 07:07:31 +02:00
|
|
|
stat = ce;
|
2005-04-19 20:41:18 +02:00
|
|
|
active_nr--;
|
|
|
|
continue;
|
|
|
|
}
|
2005-06-06 07:07:31 +02:00
|
|
|
if (path_matches(ce, stat) && same(ce, stat))
|
|
|
|
*ce = *stat;
|
2005-04-19 20:41:18 +02:00
|
|
|
ce->ce_flags &= ~htons(CE_STAGEMASK);
|
|
|
|
*dst++ = ce;
|
2005-04-16 07:53:45 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-06-06 07:07:31 +02: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);
|
|
|
|
while (nr--) {
|
|
|
|
struct cache_entry *ce = *src++;
|
|
|
|
if (ce->ce_flags & mask) {
|
|
|
|
ce->ce_flags &= ~mask;
|
|
|
|
if (update)
|
|
|
|
checkout_entry(ce, &state);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *read_tree_usage = "git-read-tree (<sha> | -m <sha1> [<sha2> [<sha3>]])";
|
2005-04-21 04:49:16 +02:00
|
|
|
|
2005-06-06 21:20:55 +02:00
|
|
|
static struct cache_file cache_file;
|
|
|
|
|
2005-04-08 00:13:13 +02:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
2005-04-19 20:16:12 +02:00
|
|
|
int i, newfd, merge;
|
2005-04-08 00:13:13 +02:00
|
|
|
unsigned char sha1[20];
|
2005-04-21 19:55:18 +02:00
|
|
|
|
2005-06-06 21:20:55 +02:00
|
|
|
newfd = hold_index_file_for_update(&cache_file, get_index_file());
|
2005-04-09 21:11:25 +02:00
|
|
|
if (newfd < 0)
|
2005-04-13 11:28:48 +02:00
|
|
|
die("unable to create new cachefile");
|
2005-04-09 21:11:25 +02:00
|
|
|
|
2005-04-19 20:16:12 +02:00
|
|
|
merge = 0;
|
2005-04-09 21:11:25 +02:00
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
const char *arg = argv[i];
|
|
|
|
|
2005-06-06 07:07:31 +02:00
|
|
|
/* "-u" means "update", meaning that a merge will update the working directory */
|
|
|
|
if (!strcmp(arg, "-u")) {
|
|
|
|
update = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-04-16 07:53:45 +02:00
|
|
|
/* "-m" stands for "merge", meaning we start in stage 1 */
|
2005-04-09 21:11:25 +02:00
|
|
|
if (!strcmp(arg, "-m")) {
|
2005-04-19 20:16:12 +02:00
|
|
|
int i;
|
|
|
|
if (stage)
|
2005-04-21 04:49:16 +02:00
|
|
|
die("-m needs to come first");
|
2005-04-19 20:16:12 +02:00
|
|
|
read_cache();
|
|
|
|
for (i = 0; i < active_nr; i++) {
|
|
|
|
if (ce_stage(active_cache[i]))
|
2005-04-21 04:49:16 +02:00
|
|
|
die("you need to resolve your current index first");
|
2005-04-19 20:16:12 +02:00
|
|
|
}
|
2005-04-16 07:53:45 +02:00
|
|
|
stage = 1;
|
2005-04-19 20:16:12 +02:00
|
|
|
merge = 1;
|
2005-04-09 21:11:25 +02:00
|
|
|
continue;
|
|
|
|
}
|
2005-05-02 01:36:56 +02:00
|
|
|
if (get_sha1(arg, sha1) < 0)
|
2005-04-21 04:49:16 +02:00
|
|
|
usage(read_tree_usage);
|
2005-04-16 07:53:45 +02:00
|
|
|
if (stage > 3)
|
2005-04-21 04:49:16 +02:00
|
|
|
usage(read_tree_usage);
|
2005-04-23 01:42:37 +02:00
|
|
|
if (unpack_tree(sha1) < 0)
|
2005-04-13 11:28:48 +02:00
|
|
|
die("failed to unpack tree object %s", arg);
|
2005-04-16 07:53:45 +02:00
|
|
|
stage++;
|
2005-04-09 21:11:25 +02:00
|
|
|
}
|
2005-04-19 20:16:12 +02:00
|
|
|
if (merge) {
|
2005-04-19 20:41:18 +02:00
|
|
|
switch (stage) {
|
|
|
|
case 4: /* Three-way merge */
|
|
|
|
trivially_merge_cache(active_cache, active_nr);
|
2005-06-06 07:07:31 +02:00
|
|
|
check_updates(active_cache, active_nr);
|
|
|
|
break;
|
|
|
|
case 3: /* Update from one tree to another */
|
|
|
|
twoway_merge(active_cache, active_nr);
|
|
|
|
check_updates(active_cache, active_nr);
|
2005-04-19 20:41:18 +02:00
|
|
|
break;
|
|
|
|
case 2: /* Just read a tree, merge with old cache contents */
|
|
|
|
merge_stat_info(active_cache, active_nr);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
die("just how do you expect me to merge %d trees?", stage-1);
|
|
|
|
}
|
2005-04-19 20:16:12 +02:00
|
|
|
}
|
2005-06-06 21:20:55 +02:00
|
|
|
if (write_cache(newfd, active_cache, active_nr) ||
|
|
|
|
commit_index_file(&cache_file))
|
2005-04-13 11:28:48 +02:00
|
|
|
die("unable to write new index file");
|
2005-04-12 00:39:26 +02:00
|
|
|
return 0;
|
2005-04-08 00:13:13 +02:00
|
|
|
}
|