2 * GIT - The information manager from hell
4 * Copyright (C) Linus Torvalds, 2005
10 static int unpack_tree(unsigned char *sha1)
16 buffer = read_object_with_reference(sha1, "tree", &size, NULL);
19 ret = read_tree(buffer, size, stage);
24 static char *lockfile_name;
26 static void remove_lock_file(void)
29 unlink(lockfile_name);
32 static int path_matches(struct cache_entry *a, struct cache_entry *b)
34 int len = ce_namelen(a);
35 return ce_namelen(b) == len &&
36 !memcmp(a->name, b->name, len);
39 static int same(struct cache_entry *a, struct cache_entry *b)
41 return a->ce_mode == b->ce_mode &&
42 !memcmp(a->sha1, b->sha1, 20);
47 * This removes all trivial merges that don't change the tree
48 * and collapses them to state 0.
50 * _Any_ other merge is left to user policy. That includes "both
51 * created the same file", and "both removed the same file" - which are
52 * trivial, but the user might still want to _note_ it.
54 static struct cache_entry *merge_entries(struct cache_entry *a,
55 struct cache_entry *b,
56 struct cache_entry *c)
58 int len = ce_namelen(a);
61 * Are they all the same filename? We won't do
64 if (ce_namelen(b) != len ||
65 ce_namelen(c) != len ||
66 memcmp(a->name, b->name, len) ||
67 memcmp(a->name, c->name, len))
71 * Ok, all three entries describe the same
72 * filename, but maybe the contents or file
75 * The trivial cases end up being the ones where two
76 * out of three files are the same:
77 * - both destinations the same, trivially take either
78 * - one of the destination versions hasn't changed,
81 * The "all entries exactly the same" case falls out as
82 * a special case of any of the "two same" cases.
84 * Here "a" is "original", and "b" and "c" are the two
85 * trees we are merging.
97 * When a CE gets turned into an unmerged entry, we
98 * want it to be up-to-date
100 static void verify_uptodate(struct cache_entry *ce)
104 if (!lstat(ce->name, &st)) {
105 unsigned changed = ce_match_stat(ce, &st);
112 die("Entry '%s' not uptodate. Cannot merge.", ce->name);
116 * If the old tree contained a CE that isn't even in the
117 * result, that's always a problem, regardless of whether
118 * it's up-to-date or not (ie it can be a file that we
119 * have updated but not committed yet).
121 static void reject_merge(struct cache_entry *ce)
123 die("Entry '%s' would be overwritten by merge. Cannot merge.", ce->name);
126 #define CHECK_OLD(ce) if (old && same(old, ce)) { verify_uptodate(old); old = NULL; }
128 static void trivially_merge_cache(struct cache_entry **src, int nr)
130 struct cache_entry **dst = src;
131 struct cache_entry *old = NULL;
134 struct cache_entry *ce, *result;
138 /* We throw away original cache entries except for the stat information */
148 if (old && !path_matches(old, ce))
150 if (nr > 2 && (result = merge_entries(ce, src[1], src[2])) != NULL) {
152 * See if we can re-use the old CE directly?
153 * That way we get the uptodate stat info.
155 if (old && same(old, result)) {
163 ce->ce_flags &= ~htons(CE_STAGEMASK);
170 * If we had an old entry that we now effectively
171 * overwrite, make sure it wasn't dirty.
182 static void merge_stat_info(struct cache_entry **src, int nr)
184 static struct cache_entry null_entry;
185 struct cache_entry **dst = src;
186 struct cache_entry *old = &null_entry;
189 struct cache_entry *ce;
193 /* We throw away original cache entries except for the stat information */
201 if (path_matches(ce, old) && same(ce, old))
203 ce->ce_flags &= ~htons(CE_STAGEMASK);
210 static char *read_tree_usage = "git-read-tree (<sha> | -m <sha1> [<sha2> <sha3>])";
212 int main(int argc, char **argv)
215 unsigned char sha1[20];
216 static char lockfile[MAXPATHLEN+1];
217 const char *indexfile = get_index_file();
219 snprintf(lockfile, sizeof(lockfile), "%s.lock", indexfile);
221 newfd = open(lockfile, O_RDWR | O_CREAT | O_EXCL, 0600);
223 die("unable to create new cachefile");
224 atexit(remove_lock_file);
225 lockfile_name = lockfile;
228 for (i = 1; i < argc; i++) {
229 const char *arg = argv[i];
231 /* "-m" stands for "merge", meaning we start in stage 1 */
232 if (!strcmp(arg, "-m")) {
235 die("-m needs to come first");
237 for (i = 0; i < active_nr; i++) {
238 if (ce_stage(active_cache[i]))
239 die("you need to resolve your current index first");
245 if (get_sha1(arg, sha1) < 0)
246 usage(read_tree_usage);
248 usage(read_tree_usage);
249 if (unpack_tree(sha1) < 0)
250 die("failed to unpack tree object %s", arg);
255 case 4: /* Three-way merge */
256 trivially_merge_cache(active_cache, active_nr);
258 case 2: /* Just read a tree, merge with old cache contents */
259 merge_stat_info(active_cache, active_nr);
262 die("just how do you expect me to merge %d trees?", stage-1);
265 if (write_cache(newfd, active_cache, active_nr) || rename(lockfile, indexfile))
266 die("unable to write new index file");
267 lockfile_name = NULL;