2 * GIT - The information manager from hell
4 * Copyright (C) Linus Torvalds, 2005
11 static int unpack_tree(unsigned char *sha1
)
17 buffer
= read_object_with_reference(sha1
, "tree", &size
, NULL
);
20 ret
= read_tree(buffer
, size
, stage
);
25 static char *lockfile_name
;
27 static void remove_lock_file(void)
30 unlink(lockfile_name
);
33 static int path_matches(struct cache_entry
*a
, struct cache_entry
*b
)
35 int len
= ce_namelen(a
);
36 return ce_namelen(b
) == len
&&
37 !memcmp(a
->name
, b
->name
, len
);
40 static int same(struct cache_entry
*a
, struct cache_entry
*b
)
42 return a
->ce_mode
== b
->ce_mode
&&
43 !memcmp(a
->sha1
, b
->sha1
, 20);
48 * This removes all trivial merges that don't change the tree
49 * and collapses them to state 0.
51 * _Any_ other merge is left to user policy. That includes "both
52 * created the same file", and "both removed the same file" - which are
53 * trivial, but the user might still want to _note_ it.
55 static struct cache_entry
*merge_entries(struct cache_entry
*a
,
56 struct cache_entry
*b
,
57 struct cache_entry
*c
)
59 int len
= ce_namelen(a
);
62 * Are they all the same filename? We won't do
65 if (ce_namelen(b
) != len
||
66 ce_namelen(c
) != len
||
67 memcmp(a
->name
, b
->name
, len
) ||
68 memcmp(a
->name
, c
->name
, len
))
72 * Ok, all three entries describe the same
73 * filename, but maybe the contents or file
76 * The trivial cases end up being the ones where two
77 * out of three files are the same:
78 * - both destinations the same, trivially take either
79 * - one of the destination versions hasn't changed,
82 * The "all entries exactly the same" case falls out as
83 * a special case of any of the "two same" cases.
85 * Here "a" is "original", and "b" and "c" are the two
86 * trees we are merging.
98 * When a CE gets turned into an unmerged entry, we
99 * want it to be up-to-date
101 static void verify_uptodate(struct cache_entry
*ce
)
105 if (!lstat(ce
->name
, &st
)) {
106 unsigned changed
= ce_match_stat(ce
, &st
);
113 die("Entry '%s' not uptodate. Cannot merge.", ce
->name
);
117 * If the old tree contained a CE that isn't even in the
118 * result, that's always a problem, regardless of whether
119 * it's up-to-date or not (ie it can be a file that we
120 * have updated but not committed yet).
122 static void reject_merge(struct cache_entry
*ce
)
124 die("Entry '%s' would be overwritten by merge. Cannot merge.", ce
->name
);
127 #define CHECK_OLD(ce) if (old && same(old, ce)) { verify_uptodate(old); old = NULL; }
129 static void trivially_merge_cache(struct cache_entry
**src
, int nr
)
131 struct cache_entry
**dst
= src
;
132 struct cache_entry
*old
= NULL
;
135 struct cache_entry
*ce
, *result
;
139 /* We throw away original cache entries except for the stat information */
147 if (old
&& !path_matches(old
, ce
))
149 if (nr
> 1 && (result
= merge_entries(ce
, src
[0], src
[1])) != NULL
) {
150 result
->ce_flags
|= htons(CE_UPDATE
);
152 * See if we can re-use the old CE directly?
153 * That way we get the uptodate stat info.
155 * This also removes the UPDATE flag on
158 if (old
&& same(old
, result
)) {
166 ce
->ce_flags
&= ~htons(CE_STAGEMASK
);
173 * If we had an old entry that we now effectively
174 * overwrite, make sure it wasn't dirty.
184 * When we find a "stage2" entry in the two-way merge, that's
185 * the one that will remain. If we have an exact old match,
186 * we don't care whether the file is up-to-date or not, we just
187 * re-use the thing directly.
189 * If we didn't have an exact match, then we want to make sure
190 * that we've seen a stage1 that matched the old, and that the
191 * old file was up-to-date. Because it will be gone after this
194 static void twoway_check(struct cache_entry
*old
, int seen_stage1
, struct cache_entry
*ce
)
196 if (path_matches(old
, ce
)) {
198 * This also removes the UPDATE flag on
208 verify_uptodate(old
);
215 * - every current entry has to match the old tree
216 * - if the current entry matches the new tree, we leave it
217 * as-is. Otherwise we require that it be up-to-date.
219 static void twoway_merge(struct cache_entry
**src
, int nr
)
222 struct cache_entry
*old
= NULL
;
223 struct cache_entry
**dst
= src
;
226 struct cache_entry
*ce
= *src
++;
227 int stage
= ce_stage(ce
);
242 if (!path_matches(old
, ce
) || !same(old
, ce
))
248 ce
->ce_flags
|= htons(CE_UPDATE
);
250 twoway_check(old
, seen_stage1
, ce
);
253 ce
->ce_flags
&= ~htons(CE_STAGEMASK
);
257 die("impossible two-way stage");
261 * Unmatched with a new entry? Make sure it was
262 * at least uptodate in the working directory _and_
263 * the original tree..
268 verify_uptodate(old
);
272 static void merge_stat_info(struct cache_entry
**src
, int nr
)
274 static struct cache_entry null_entry
;
275 struct cache_entry
**dst
= src
;
276 struct cache_entry
*stat
= &null_entry
;
279 struct cache_entry
*ce
= *src
++;
281 /* We throw away original cache entries except for the stat information */
287 if (path_matches(ce
, stat
) && same(ce
, stat
))
289 ce
->ce_flags
&= ~htons(CE_STAGEMASK
);
294 static void check_updates(struct cache_entry
**src
, int nr
)
296 static struct checkout state
= {
302 unsigned short mask
= htons(CE_UPDATE
);
304 struct cache_entry
*ce
= *src
++;
305 if (ce
->ce_flags
& mask
) {
306 ce
->ce_flags
&= ~mask
;
308 checkout_entry(ce
, &state
);
313 static char *read_tree_usage
= "git-read-tree (<sha> | -m <sha1> [<sha2> [<sha3>]])";
315 int main(int argc
, char **argv
)
318 unsigned char sha1
[20];
319 static char lockfile
[MAXPATHLEN
+1];
320 const char *indexfile
= get_index_file();
322 snprintf(lockfile
, sizeof(lockfile
), "%s.lock", indexfile
);
324 newfd
= open(lockfile
, O_RDWR
| O_CREAT
| O_EXCL
, 0600);
326 die("unable to create new cachefile");
327 atexit(remove_lock_file
);
328 lockfile_name
= lockfile
;
331 for (i
= 1; i
< argc
; i
++) {
332 const char *arg
= argv
[i
];
334 /* "-u" means "update", meaning that a merge will update the working directory */
335 if (!strcmp(arg
, "-u")) {
340 /* "-m" stands for "merge", meaning we start in stage 1 */
341 if (!strcmp(arg
, "-m")) {
344 die("-m needs to come first");
346 for (i
= 0; i
< active_nr
; i
++) {
347 if (ce_stage(active_cache
[i
]))
348 die("you need to resolve your current index first");
354 if (get_sha1(arg
, sha1
) < 0)
355 usage(read_tree_usage
);
357 usage(read_tree_usage
);
358 if (unpack_tree(sha1
) < 0)
359 die("failed to unpack tree object %s", arg
);
364 case 4: /* Three-way merge */
365 trivially_merge_cache(active_cache
, active_nr
);
366 check_updates(active_cache
, active_nr
);
368 case 3: /* Update from one tree to another */
369 twoway_merge(active_cache
, active_nr
);
370 check_updates(active_cache
, active_nr
);
372 case 2: /* Just read a tree, merge with old cache contents */
373 merge_stat_info(active_cache
, active_nr
);
376 die("just how do you expect me to merge %d trees?", stage
-1);
379 if (write_cache(newfd
, active_cache
, active_nr
) || rename(lockfile
, indexfile
))
380 die("unable to write new index file");
381 lockfile_name
= NULL
;