b72ee1c54c092067da0bc35492ae9dead5e990bb
1 /*
2 * GIT - The information manager from hell
3 *
4 * Copyright (C) Linus Torvalds, 2005
5 */
6 #include "cache.h"
8 static int stage = 0;
9 static int update = 0;
11 static int unpack_tree(unsigned char *sha1)
12 {
13 void *buffer;
14 unsigned long size;
15 int ret;
17 buffer = read_object_with_reference(sha1, "tree", &size, NULL);
18 if (!buffer)
19 return -1;
20 ret = read_tree(buffer, size, stage);
21 free(buffer);
22 return ret;
23 }
25 static char *lockfile_name;
27 static void remove_lock_file(void)
28 {
29 if (lockfile_name)
30 unlink(lockfile_name);
31 }
33 static int path_matches(struct cache_entry *a, struct cache_entry *b)
34 {
35 int len = ce_namelen(a);
36 return ce_namelen(b) == len &&
37 !memcmp(a->name, b->name, len);
38 }
40 static int same(struct cache_entry *a, struct cache_entry *b)
41 {
42 return a->ce_mode == b->ce_mode &&
43 !memcmp(a->sha1, b->sha1, 20);
44 }
47 /*
48 * This removes all trivial merges that don't change the tree
49 * and collapses them to state 0.
50 *
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.
54 */
55 static struct cache_entry *merge_entries(struct cache_entry *a,
56 struct cache_entry *b,
57 struct cache_entry *c)
58 {
59 int len = ce_namelen(a);
61 /*
62 * Are they all the same filename? We won't do
63 * any name merging
64 */
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))
69 return NULL;
71 /*
72 * Ok, all three entries describe the same
73 * filename, but maybe the contents or file
74 * mode have changed?
75 *
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,
80 * take the other.
81 *
82 * The "all entries exactly the same" case falls out as
83 * a special case of any of the "two same" cases.
84 *
85 * Here "a" is "original", and "b" and "c" are the two
86 * trees we are merging.
87 */
88 if (same(b,c))
89 return c;
90 if (same(a,b))
91 return c;
92 if (same(a,c))
93 return b;
94 return NULL;
95 }
97 /*
98 * When a CE gets turned into an unmerged entry, we
99 * want it to be up-to-date
100 */
101 static void verify_uptodate(struct cache_entry *ce)
102 {
103 struct stat st;
105 if (!lstat(ce->name, &st)) {
106 unsigned changed = ce_match_stat(ce, &st);
107 if (!changed)
108 return;
109 errno = 0;
110 }
111 if (errno == ENOENT)
112 return;
113 die("Entry '%s' not uptodate. Cannot merge.", ce->name);
114 }
116 /*
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).
121 */
122 static void reject_merge(struct cache_entry *ce)
123 {
124 die("Entry '%s' would be overwritten by merge. Cannot merge.", ce->name);
125 }
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)
130 {
131 struct cache_entry **dst = src;
132 struct cache_entry *old = NULL;
134 while (nr--) {
135 struct cache_entry *ce, *result;
137 ce = *src++;
139 /* We throw away original cache entries except for the stat information */
140 if (!ce_stage(ce)) {
141 if (old)
142 reject_merge(old);
143 old = ce;
144 active_nr--;
145 continue;
146 }
147 if (old && !path_matches(old, ce))
148 reject_merge(old);
149 if (nr > 2 && (result = merge_entries(ce, src[0], src[1])) != NULL) {
150 result->ce_flags |= htons(CE_UPDATE);
151 /*
152 * See if we can re-use the old CE directly?
153 * That way we get the uptodate stat info.
154 *
155 * This also removes the UPDATE flag on
156 * a match.
157 */
158 if (old && same(old, result)) {
159 *result = *old;
160 old = NULL;
161 }
162 CHECK_OLD(ce);
163 CHECK_OLD(src[0]);
164 CHECK_OLD(src[1]);
165 ce = result;
166 ce->ce_flags &= ~htons(CE_STAGEMASK);
167 src += 2;
168 nr -= 2;
169 active_nr -= 2;
170 }
172 /*
173 * If we had an old entry that we now effectively
174 * overwrite, make sure it wasn't dirty.
175 */
176 CHECK_OLD(ce);
177 *dst++ = ce;
178 }
179 if (old)
180 reject_merge(old);
181 }
183 /*
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.
188 *
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
192 * merge..
193 */
194 static void twoway_check(struct cache_entry *old, int seen_stage1, struct cache_entry *ce)
195 {
196 if (path_matches(old, ce)) {
197 /*
198 * This also removes the UPDATE flag on
199 * a match
200 */
201 if (same(old, ce)) {
202 *ce = *old;
203 return;
204 }
205 if (!seen_stage1)
206 reject_merge(old);
207 }
208 verify_uptodate(old);
209 }
211 /*
212 * Two-way merge.
213 *
214 * The rule is:
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.
218 */
219 static void twoway_merge(struct cache_entry **src, int nr)
220 {
221 int seen_stage1 = 0;
222 struct cache_entry *old = NULL;
223 struct cache_entry **dst = src;
225 while (nr--) {
226 struct cache_entry *ce = *src++;
227 int stage = ce_stage(ce);
229 switch (stage) {
230 case 0:
231 if (old)
232 reject_merge(old);
233 old = ce;
234 seen_stage1 = 0;
235 active_nr--;
236 continue;
238 case 1:
239 active_nr--;
240 if (!old)
241 continue;
242 if (!path_matches(old, ce) || !same(old, ce))
243 reject_merge(old);
244 seen_stage1 = 1;
245 continue;
247 case 2:
248 ce->ce_flags |= htons(CE_UPDATE);
249 if (old) {
250 twoway_check(old, seen_stage1, ce);
251 old = NULL;
252 }
253 ce->ce_flags &= ~htons(CE_STAGEMASK);
254 *dst++ = ce;
255 continue;
256 }
257 die("impossible two-way stage");
258 }
260 /*
261 * Unmatched with a new entry? Make sure it was
262 * at least uptodate in the working directory _and_
263 * the original tree..
264 */
265 if (old) {
266 if (!seen_stage1)
267 reject_merge(old);
268 verify_uptodate(old);
269 }
270 }
272 static void merge_stat_info(struct cache_entry **src, int nr)
273 {
274 static struct cache_entry null_entry;
275 struct cache_entry **dst = src;
276 struct cache_entry *stat = &null_entry;
278 while (nr--) {
279 struct cache_entry *ce = *src++;
281 /* We throw away original cache entries except for the stat information */
282 if (!ce_stage(ce)) {
283 stat = ce;
284 active_nr--;
285 continue;
286 }
287 if (path_matches(ce, stat) && same(ce, stat))
288 *ce = *stat;
289 ce->ce_flags &= ~htons(CE_STAGEMASK);
290 *dst++ = ce;
291 }
292 }
294 static void check_updates(struct cache_entry **src, int nr)
295 {
296 static struct checkout state = {
297 .base_dir = "",
298 .force = 1,
299 .quiet = 1,
300 .refresh_cache = 1,
301 };
302 unsigned short mask = htons(CE_UPDATE);
303 while (nr--) {
304 struct cache_entry *ce = *src++;
305 if (ce->ce_flags & mask) {
306 ce->ce_flags &= ~mask;
307 if (update)
308 checkout_entry(ce, &state);
309 }
310 }
311 }
313 static char *read_tree_usage = "git-read-tree (<sha> | -m <sha1> [<sha2> [<sha3>]])";
315 int main(int argc, char **argv)
316 {
317 int i, newfd, merge;
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);
325 if (newfd < 0)
326 die("unable to create new cachefile");
327 atexit(remove_lock_file);
328 lockfile_name = lockfile;
330 merge = 0;
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")) {
336 update = 1;
337 continue;
338 }
340 /* "-m" stands for "merge", meaning we start in stage 1 */
341 if (!strcmp(arg, "-m")) {
342 int i;
343 if (stage)
344 die("-m needs to come first");
345 read_cache();
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");
349 }
350 stage = 1;
351 merge = 1;
352 continue;
353 }
354 if (get_sha1(arg, sha1) < 0)
355 usage(read_tree_usage);
356 if (stage > 3)
357 usage(read_tree_usage);
358 if (unpack_tree(sha1) < 0)
359 die("failed to unpack tree object %s", arg);
360 stage++;
361 }
362 if (merge) {
363 switch (stage) {
364 case 4: /* Three-way merge */
365 trivially_merge_cache(active_cache, active_nr);
366 check_updates(active_cache, active_nr);
367 break;
368 case 3: /* Update from one tree to another */
369 twoway_merge(active_cache, active_nr);
370 check_updates(active_cache, active_nr);
371 break;
372 case 2: /* Just read a tree, merge with old cache contents */
373 merge_stat_info(active_cache, active_nr);
374 break;
375 default:
376 die("just how do you expect me to merge %d trees?", stage-1);
377 }
378 }
379 if (write_cache(newfd, active_cache, active_nr) || rename(lockfile, indexfile))
380 die("unable to write new index file");
381 lockfile_name = NULL;
382 return 0;
383 }