{
if (!a && !b)
return 2;
- return a && b && memcmp(a, b, 20) == 0;
+ return a && b && hashcmp(a, b) == 0;
}
/*
if (commit->util)
printf("virtual %s\n", (char *)commit->util);
else {
- printf("%s ", sha1_to_hex(commit->object.sha1));
+ printf("%s ", find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV));
if (parse_commit(commit) != 0)
printf("(bad commit)\n");
else {
{
/* flush temporary index */
struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
- int fd = hold_lock_file_for_update(lock, current_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", current_index_file);
static void setup_index(int temp)
{
current_index_file = temp ? temporary_index_file: original_index_file;
- if (cache_dirty)
- die("fatal: cache changed flush_cache();");
+ if (cache_dirty) {
+ discard_cache();
+ cache_dirty = 0;
+ }
unlink(temporary_index_file);
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);
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';
}
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;
return renames;
}
-int update_stages(const char *path, struct diff_filespec *o,
- struct diff_filespec *a, struct diff_filespec *b, int clear)
+static int update_stages(const char *path, struct diff_filespec *o,
+ struct diff_filespec *a, struct diff_filespec *b,
+ int clear)
{
int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE;
if (clear)
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;
}
-int remove_file(int clean, const char *path)
+static int remove_file(int clean, const char *path, int no_wd)
{
int update_cache = index_only || clean;
- int update_working_directory = !index_only;
+ int update_working_directory = !index_only && !no_wd;
if (update_cache) {
if (!cache_dirty)
if (remove_file_from_cache(path))
return -1;
}
- if (update_working_directory)
- {
+ if (update_working_directory) {
unlink(path);
if (errno != ENOENT || errno != EISDIR)
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;
}
}
-void update_file_flags(const unsigned char *sha,
- unsigned mode,
- const char *path,
- int update_cache,
- int update_wd)
+static void update_file_flags(const unsigned char *sha,
+ unsigned mode,
+ const char *path,
+ int update_cache,
+ int update_wd)
{
if (index_only)
update_wd = 0;
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);
add_cacheinfo(mode, sha, path, 0, update_wd, ADD_CACHE_OK_TO_ADD);
}
-void update_file(int clean,
- const unsigned char *sha,
- unsigned mode,
- const char *path)
+static void update_file(int clean,
+ const unsigned char *sha,
+ unsigned mode,
+ const char *path)
{
update_file_flags(sha, mode, path, index_only || clean, !index_only);
}
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;
dst_name1 = del[delp++] = unique_path(ren1_dst, branch1);
output("%s is a directory in %s adding as %s instead",
ren1_dst, branch2, dst_name1);
- remove_file(0, ren1_dst);
+ remove_file(0, ren1_dst, 0);
}
if (path_list_has_path(¤t_directory_set, ren2_dst)) {
dst_name2 = del[delp++] = unique_path(ren2_dst, branch2);
output("%s is a directory in %s adding as %s instead",
ren2_dst, branch1, dst_name2);
- remove_file(0, ren2_dst);
+ remove_file(0, ren2_dst, 0);
}
update_stages(dst_name1, NULL, ren1->pair->two, NULL, 1);
update_stages(dst_name2, NULL, NULL, ren2->pair->two, 1);
{
char *new_path = unique_path(ren1->pair->two->path, branch1);
output("Renaming %s to %s instead", ren1->pair->one->path, new_path);
- remove_file(0, ren1->pair->two->path);
+ remove_file(0, ren1->pair->two->path, 0);
update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, new_path);
free(new_path);
}
output("Renaming %s to %s and %s to %s instead",
ren1->pair->one->path, new_path1,
ren2->pair->one->path, new_path2);
- remove_file(0, ren1->pair->two->path);
+ remove_file(0, ren1->pair->two->path, 0);
update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, new_path1);
update_file(0, ren2->pair->two->sha1, ren2->pair->two->mode, new_path2);
free(new_path2);
conflict_rename_rename(ren1, branch1, ren2, branch2);
} else {
struct merge_file_info mfi;
- remove_file(1, ren1_src);
+ remove_file(1, ren1_src, 1);
mfi = merge_file(ren1->pair->one,
ren1->pair->two,
ren2->pair->two,
struct diff_filespec src_other, dst_other;
int try_merge, stage = a_renames == renames1 ? 3: 2;
- remove_file(1, ren1_src);
+ remove_file(1, ren1_src, 1);
- 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 */
* unchanged in the other */
if (a_sha)
output("Removing %s", path);
- remove_file(1, path);
+ /* do not touch working file if it did not exist */
+ remove_file(1, path, !a_sha);
} else {
/* Deleted in one and changed in the other */
clean_merge = 0;
output("CONFLICT (%s): There is a directory with name %s in %s. "
"Adding %s as %s",
conf, path, other_branch, path, new_path);
- remove_file(0, path);
+ remove_file(0, path, 0);
update_file(0, sha, mode, new_path);
} else {
output("Adding %s", path);
output("CONFLICT (add/add): File %s added non-identically "
"in both branches. Adding as %s and %s instead.",
path, new_path1, new_path2);
- remove_file(0, path);
+ remove_file(0, path, 0);
update_file(0, a_sha, a_mode, new_path1);
update_file(0, b_sha, b_mode, new_path2);
}
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.
*/
-static
-int merge(struct commit *h1,
- struct commit *h2,
- const char *branch1,
- const char *branch2,
- int call_depth /* =0 */,
- struct commit *ancestor /* =None */,
- struct commit **result)
+static int merge(struct commit *h1,
+ struct commit *h2,
+ const char *branch1,
+ const char *branch2,
+ int call_depth /* =0 */,
+ struct commit *ancestor /* =None */,
+ struct commit **result)
{
struct commit_list *ca = NULL, *iter;
struct commit *merged_common_ancestors;
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;
+ write_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;
const char *branch1, *branch2;
struct commit *result, *h1, *h2;
+ git_config(git_default_config); /* core.filemode */
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]);