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
;