![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/merge-recursive.c b/merge-recursive.c
index b8b095179bfb581611ced221e1bdcca2b05a07b9..2ba43ae84b20f993ba175f728297cf5360066872 100644 (file)
--- a/merge-recursive.c
+++ b/merge-recursive.c
{
if (!a && !b)
return 2;
- return a && b && memcmp(a, b, 20) == 0;
+ return a && b && hashcmp(a, b) == 0;
}
/*
}
}
+static const char *current_index_file = NULL;
static const char *original_index_file;
static const char *temporary_index_file;
static int cache_dirty = 0;
{
/* flush temporary index */
struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
- int fd = hold_lock_file_for_update(lock, getenv("GIT_INDEX_FILE"));
- if (fd < 0)
- die("could not lock %s", lock->filename);
+ int fd = hold_lock_file_for_update(lock, current_index_file, 1);
if (write_cache(fd, active_cache, active_nr) ||
close(fd) || commit_lock_file(lock))
- die ("unable to write %s", getenv("GIT_INDEX_FILE"));
+ die ("unable to write %s", current_index_file);
discard_cache();
cache_dirty = 0;
return 0;
static void setup_index(int temp)
{
- const char *idx = temp ? temporary_index_file: original_index_file;
- if (cache_dirty)
- die("fatal: cache changed flush_cache();");
+ current_index_file = temp ? temporary_index_file: original_index_file;
+ if (cache_dirty) {
+ discard_cache();
+ cache_dirty = 0;
+ }
unlink(temporary_index_file);
- setenv("GIT_INDEX_FILE", idx, 1);
discard_cache();
}
size = cache_entry_size(len);
ce = xcalloc(1, size);
- memcpy(ce->sha1, sha1, 20);
+ hashcpy(ce->sha1, sha1);
memcpy(ce->name, path, len);
ce->ce_flags = create_ce_flags(len, stage);
ce->ce_mode = create_ce_mode(mode);
{
struct cache_entry *ce;
if (!cache_dirty)
- read_cache_from(getenv("GIT_INDEX_FILE"));
+ read_cache_from(current_index_file);
cache_dirty++;
ce = make_cache_entry(mode, sha1 ? sha1 : null_sha1, path, stage, refresh);
if (!ce)
struct unpack_trees_options opts;
if (!cache_dirty) {
- read_cache_from(getenv("GIT_INDEX_FILE"));
+ read_cache_from(current_index_file);
cache_dirty = 1;
}
return NULL;
}
} else
- read_cache_from(getenv("GIT_INDEX_FILE"));
+ read_cache_from(current_index_file);
if (!active_cache_tree)
active_cache_tree = cache_tree();
unsigned int mode, int stage)
{
int len = strlen(path);
- char *newpath = malloc(baselen + len + 1);
+ char *newpath = xmalloc(baselen + len + 1);
memcpy(newpath, base, baselen);
memcpy(newpath + baselen, path, len);
newpath[baselen + len] = '\0';
unmerged->strdup_paths = 1;
if (!cache_dirty) {
- read_cache_from(getenv("GIT_INDEX_FILE"));
+ read_cache_from(current_index_file);
cache_dirty++;
}
for (i = 0; i < active_nr; i++) {
}
e = item->util;
e->stages[ce_stage(ce)].mode = ntohl(ce->ce_mode);
- memcpy(e->stages[ce_stage(ce)].sha, ce->sha1, 20);
+ hashcpy(e->stages[ce_stage(ce)].sha, ce->sha1);
}
return unmerged;
if (ret)
return ret;
len = strlen(name);
- dirs = malloc(len+1);
+ dirs = xmalloc(len+1);
memcpy(dirs, name, len);
dirs[len] = '\0';
while ((slash = strrchr(name, '/'))) {
return ret;
}
-/*
- * TODO: once we no longer call external programs, we'd probably be better off
- * not setting / getting the environment variable GIT_INDEX_FILE all the time.
- */
int remove_file(int clean, const char *path)
{
int update_cache = index_only || clean;
if (update_cache) {
if (!cache_dirty)
- read_cache_from(getenv("GIT_INDEX_FILE"));
+ read_cache_from(current_index_file);
cache_dirty++;
if (remove_file_from_cache(path))
return -1;
static int mkdir_p(const char *path, unsigned long mode)
{
- /* path points to cache entries, so strdup before messing with it */
- char *buf = strdup(path);
+ /* path points to cache entries, so xstrdup before messing with it */
+ char *buf = xstrdup(path);
int result = safe_create_leading_directories(buf);
free(buf);
return result;
flush_buffer(fd, buf, size);
close(fd);
} else if (S_ISLNK(mode)) {
- char *lnk = malloc(size + 1);
+ char *lnk = xmalloc(size + 1);
memcpy(lnk, buf, size);
lnk[size] = '\0';
mkdir_p(path, 0777);
result.clean = 0;
if (S_ISREG(a->mode)) {
result.mode = a->mode;
- memcpy(result.sha, a->sha1, 20);
+ hashcpy(result.sha, a->sha1);
} else {
result.mode = b->mode;
- memcpy(result.sha, b->sha1, 20);
+ hashcpy(result.sha, b->sha1);
}
} else {
if (!sha_eq(a->sha1, o->sha1) && !sha_eq(b->sha1, o->sha1))
result.mode = a->mode == o->mode ? b->mode: a->mode;
if (sha_eq(a->sha1, o->sha1))
- memcpy(result.sha, b->sha1, 20);
+ hashcpy(result.sha, b->sha1);
else if (sha_eq(b->sha1, o->sha1))
- memcpy(result.sha, a->sha1, 20);
+ hashcpy(result.sha, a->sha1);
else if (S_ISREG(a->mode)) {
int code = 1, fd;
struct stat st;
git_unpack_file(a->sha1, src1);
git_unpack_file(b->sha1, src2);
- argv[2] = la = strdup(mkpath("%s/%s", branch1, a->path));
- argv[6] = lb = strdup(mkpath("%s/%s", branch2, b->path));
- argv[4] = lo = strdup(mkpath("orig/%s", o->path));
+ argv[2] = la = xstrdup(mkpath("%s/%s", branch1, a->path));
+ argv[6] = lb = xstrdup(mkpath("%s/%s", branch2, b->path));
+ argv[4] = lo = xstrdup(mkpath("orig/%s", o->path));
argv[7] = src1;
argv[8] = orig;
argv[9] = src2,
if (!(S_ISLNK(a->mode) || S_ISLNK(b->mode)))
die("cannot merge modes?");
- memcpy(result.sha, a->sha1, 20);
+ hashcpy(result.sha, a->sha1);
if (!sha_eq(a->sha1, b->sha1))
result.clean = 0;
remove_file(1, ren1_src);
- memcpy(src_other.sha1,
- ren1->src_entry->stages[stage].sha, 20);
+ hashcpy(src_other.sha1, ren1->src_entry->stages[stage].sha);
src_other.mode = ren1->src_entry->stages[stage].mode;
- memcpy(dst_other.sha1,
- ren1->dst_entry->stages[stage].sha, 20);
+ hashcpy(dst_other.sha1, ren1->dst_entry->stages[stage].sha);
dst_other.mode = ren1->dst_entry->stages[stage].mode;
try_merge = 0;
static unsigned char *has_sha(const unsigned char *sha)
{
- return memcmp(sha, null_sha1, 20) == 0 ? NULL: (unsigned char *)sha;
+ return is_null_sha1(sha) ? NULL: (unsigned char *)sha;
}
/* Per entry merge function */
output("Auto-merging %s", path);
o.path = a.path = b.path = (char *)path;
- memcpy(o.sha1, o_sha, 20);
+ hashcpy(o.sha1, o_sha);
o.mode = o_mode;
- memcpy(a.sha1, a_sha, 20);
+ hashcpy(a.sha1, a_sha);
a.mode = a_mode;
- memcpy(b.sha1, b_sha, 20);
+ hashcpy(b.sha1, b_sha);
b.mode = b_mode;
mfi = merge_file(&o, &a, &b,
return clean;
}
+static struct commit_list *reverse_commit_list(struct commit_list *list)
+{
+ struct commit_list *next = NULL, *current, *backup;
+ for (current = list; current; current = backup) {
+ backup = current->next;
+ current->next = next;
+ next = current;
+ }
+ return next;
+}
+
/*
* Merge the commits h1 and h2, return the resulting virtual
* commit object and a flag indicating the cleaness of the merge.
if (ancestor)
commit_list_insert(ancestor, &ca);
else
- ca = get_merge_bases(h1, h2, 1);
+ ca = reverse_commit_list(get_merge_bases(h1, h2, 1));
output("found %u common ancestor(s):", commit_list_count(ca));
for (iter = ca; iter; iter = iter->next)
output_commit_title(iter->item);
merged_common_ancestors = pop_commit(&ca);
+ if (merged_common_ancestors == NULL) {
+ /* if there is no common ancestor, make an empty tree */
+ struct tree *tree = xcalloc(1, sizeof(struct tree));
+
+ tree->object.parsed = 1;
+ tree->object.type = OBJ_TREE;
+ hash_sha1_file(NULL, 0, tree_type, tree->object.sha1);
+ merged_common_ancestors = make_virtual_commit(tree, "ancestor");
+ }
for (iter = ca; iter; iter = iter->next) {
output_indent = call_depth + 1;
original_index_file = getenv("GIT_INDEX_FILE");
if (!original_index_file)
- original_index_file = strdup(git_path("index"));
+ original_index_file = xstrdup(git_path("index"));
- temporary_index_file = strdup(git_path("mrg-rcrsv-tmp-idx"));
+ temporary_index_file = xstrdup(git_path("mrg-rcrsv-tmp-idx"));
if (argc < 4)
die("Usage: %s <base>... -- <head> <remote> ...\n", argv[0]);