#include "diffcore.h"
#include "run-command.h"
#include "tag.h"
-
+#include "unpack-trees.h"
#include "path-list.h"
/*
commit->tree = tree;
commit->util = (void*)comment;
*(int*)commit->object.sha1 = virtual_id++;
+ /* avoid warnings */
+ commit->object.parsed = 1;
return commit;
}
/*
- * TODO: we should not have to copy the SHA1s around, but rather reference
- * them. That way, sha_eq() is just sha1 == sha2.
+ * Since we use get_tree_entry(), which does not put the read object into
+ * the object pool, we cannot rely on a == b.
*/
static int sha_eq(const unsigned char *a, const unsigned char *b)
{
}
/*
- * TODO: check if we can just reuse the active_cache structure: it is already
- * sorted (by name, stage).
- * Only problem: do not write it when flushing the cache.
+ * Since we want to write the index eventually, we cannot reuse the index
+ * for these (temporary) data.
*/
struct stage_data
{
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", temporary_index_file);
+ die("could not lock %s", lock->filename);
if (write_cache(fd, active_cache, active_nr) ||
close(fd) || commit_lock_file(lock))
die ("unable to write %s", getenv("GIT_INDEX_FILE"));
*/
static int index_only = 0;
-/*
- * TODO: this can be streamlined by refactoring builtin-read-tree.c
- */
-static int git_read_tree(const struct tree *tree)
+static int git_read_tree(struct tree *tree)
{
int rc;
- const char *argv[] = { "git-read-tree", NULL, NULL, };
+ struct object_list *trees = NULL;
+ struct unpack_trees_options opts;
+
if (cache_dirty)
die("read-tree with dirty cache");
- argv[1] = sha1_to_hex(tree->object.sha1);
- rc = run_command_v(2, argv);
- return rc < 0 ? -1: rc;
+
+ memset(&opts, 0, sizeof(opts));
+ object_list_append(&tree->object, &trees);
+ rc = unpack_trees(trees, &opts);
+ cache_tree_free(&active_cache_tree);
+
+ if (rc == 0)
+ cache_dirty = 1;
+
+ return rc;
}
-/*
- * TODO: this can be streamlined by refactoring builtin-read-tree.c
- */
-static int git_merge_trees(const char *update_arg,
+static int git_merge_trees(int index_only,
struct tree *common,
struct tree *head,
struct tree *merge)
{
int rc;
- const char *argv[] = {
- "git-read-tree", NULL, "-m", NULL, NULL, NULL,
- NULL,
- };
- if (cache_dirty)
- flush_cache();
- argv[1] = update_arg;
- argv[3] = sha1_to_hex(common->object.sha1);
- argv[4] = sha1_to_hex(head->object.sha1);
- argv[5] = sha1_to_hex(merge->object.sha1);
- rc = run_command_v(6, argv);
- return rc < 0 ? -1: rc;
+ struct object_list *trees = NULL;
+ struct unpack_trees_options opts;
+
+ if (!cache_dirty) {
+ read_cache_from(getenv("GIT_INDEX_FILE"));
+ cache_dirty = 1;
+ }
+
+ memset(&opts, 0, sizeof(opts));
+ if (index_only)
+ opts.index_only = 1;
+ else
+ opts.update = 1;
+ opts.merge = 1;
+ opts.head_idx = 2;
+ opts.fn = threeway_merge;
+
+ object_list_append(&common->object, &trees);
+ object_list_append(&head->object, &trees);
+ object_list_append(&merge->object, &trees);
+
+ rc = unpack_trees(trees, &opts);
+ cache_tree_free(&active_cache_tree);
+
+ cache_dirty = 1;
+
+ return rc;
}
/*
unsigned char sha1[20];
int ch;
unsigned i = 0;
- if (cache_dirty)
+ if (cache_dirty) {
+ for (i = 0; i < active_nr; i++) {
+ struct cache_entry *ce = active_cache[i];
+ if (ce_stage(ce))
+ return NULL;
+ }
flush_cache();
+ }
fp = popen("git-write-tree 2>/dev/null", "r");
while ((ch = fgetc(fp)) != EOF)
if (i < sizeof(buf)-1 && ch >= '0' && ch <= 'f')
char *newpath = xmalloc(strlen(path) + 1 + strlen(branch) + 8 + 1);
int suffix = 0;
struct stat st;
- char *p = newpath + strlen(newpath);
+ char *p = newpath + strlen(path);
strcpy(newpath, path);
- strcat(newpath, "~");
+ *(p++) = '~';
strcpy(p, branch);
for (; *p; ++p)
if ('/' == *p)
static struct merge_file_info merge_file(struct diff_filespec *o,
struct diff_filespec *a, struct diff_filespec *b,
- const char *branch1Name, const char *branch2Name)
+ const char *branch1, const char *branch2)
{
struct merge_file_info result;
result.merge = 0;
char src2[PATH_MAX];
const char *argv[] = {
"merge", "-L", NULL, "-L", NULL, "-L", NULL,
- src1, orig, src2,
+ NULL, NULL, NULL,
NULL
};
char *la, *lb, *lo;
git_unpack_file(a->sha1, src1);
git_unpack_file(b->sha1, src2);
- argv[2] = la = strdup(mkpath("%s/%s", branch1Name, a->path));
- argv[6] = lb = strdup(mkpath("%s/%s", branch2Name, b->path));
+ 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[7] = src1;
+ argv[8] = orig;
+ argv[9] = src2,
code = run_command_v(10, argv);
} else {
compare = strcmp(a_renames->items[i].path,
b_renames->items[j].path);
- ren1 = a_renames->items[i++].util;
- ren2 = b_renames->items[j++].util;
+ if (compare <= 0)
+ ren1 = a_renames->items[i++].util;
+ if (compare >= 0)
+ ren2 = b_renames->items[j++].util;
}
/* TODO: refactor, so that 1/2 are not needed */
/* Per entry merge function */
static int process_entry(const char *path, struct stage_data *entry,
- const char *branch1Name,
- const char *branch2Name)
+ const char *branch1,
+ const char *branch2)
{
/*
printf("processing entry, clean cache: %s\n", index_only ? "yes": "no");
if (!a_sha) {
output("CONFLICT (delete/modify): %s deleted in %s "
"and modified in %s. Version %s of %s left in tree.",
- path, branch1Name,
- branch2Name, branch2Name, path);
+ path, branch1,
+ branch2, branch2, path);
update_file(0, b_sha, b_mode, path);
} else {
output("CONFLICT (delete/modify): %s deleted in %s "
"and modified in %s. Version %s of %s left in tree.",
- path, branch2Name,
- branch1Name, branch1Name, path);
+ path, branch2,
+ branch1, branch1, path);
update_file(0, a_sha, a_mode, path);
}
}
const char *conf;
if (a_sha) {
- add_branch = branch1Name;
- other_branch = branch2Name;
+ add_branch = branch1;
+ other_branch = branch2;
mode = a_mode;
sha = a_sha;
conf = "file/directory";
} else {
- add_branch = branch2Name;
- other_branch = branch1Name;
+ add_branch = branch2;
+ other_branch = branch1;
mode = b_mode;
sha = b_sha;
conf = "directory/file";
} else {
const char *new_path1, *new_path2;
clean_merge = 0;
- new_path1 = unique_path(path, branch1Name);
- new_path2 = unique_path(path, branch2Name);
+ new_path1 = unique_path(path, branch1);
+ new_path2 = unique_path(path, branch2);
output("CONFLICT (add/add): File %s added non-identically "
"in both branches. Adding as %s and %s instead.",
path, new_path1, new_path2);
b.mode = b_mode;
mfi = merge_file(&o, &a, &b,
- branch1Name, branch2Name);
+ branch1, branch2);
if (mfi.clean)
update_file(1, mfi.sha, mfi.mode, path);
static int merge_trees(struct tree *head,
struct tree *merge,
struct tree *common,
- const char *branch1Name,
- const char *branch2Name,
+ const char *branch1,
+ const char *branch2,
struct tree **result)
{
int code, clean;
return 1;
}
- code = git_merge_trees(index_only ? "-i": "-u", common, head, merge);
+ code = git_merge_trees(index_only, common, head, merge);
if (code != 0)
die("merging of trees %s and %s failed",
re_head = get_renames(head, common, head, merge, entries);
re_merge = get_renames(merge, common, head, merge, entries);
clean = process_renames(re_head, re_merge,
- branch1Name, branch2Name);
+ branch1, branch2);
for (i = 0; i < entries->nr; i++) {
const char *path = entries->items[i].path;
struct stage_data *e = entries->items[i].util;
if (e->processed)
continue;
- if (!process_entry(path, e, branch1Name, branch2Name))
+ if (!process_entry(path, e, branch1, branch2))
clean = 0;
}
static
int merge(struct commit *h1,
struct commit *h2,
- const char *branch1Name,
- const char *branch2Name,
+ const char *branch1,
+ const char *branch2,
int call_depth /* =0 */,
struct commit *ancestor /* =None */,
struct commit **result)
}
clean = merge_trees(h1->tree, h2->tree, merged_common_ancestors->tree,
- branch1Name, branch2Name, &mrtree);
+ branch1, branch2, &mrtree);
if (!ancestor && (clean || index_only)) {
*result = make_virtual_commit(mrtree, "merged tree");