alloc: allow arbitrary repositories for alloc functions
[git/git.git] / merge-recursive.c
1 /*
2 * Recursive Merge algorithm stolen from git-merge-recursive.py by
3 * Fredrik Kuivinen.
4 * The thieves were Alex Riesen and Johannes Schindelin, in June/July 2006
5 */
6 #include "cache.h"
7 #include "config.h"
8 #include "advice.h"
9 #include "lockfile.h"
10 #include "cache-tree.h"
11 #include "commit.h"
12 #include "blob.h"
13 #include "builtin.h"
14 #include "tree-walk.h"
15 #include "diff.h"
16 #include "diffcore.h"
17 #include "tag.h"
18 #include "alloc.h"
19 #include "unpack-trees.h"
20 #include "string-list.h"
21 #include "xdiff-interface.h"
22 #include "ll-merge.h"
23 #include "attr.h"
24 #include "merge-recursive.h"
25 #include "dir.h"
26 #include "submodule.h"
27
28 struct path_hashmap_entry {
29 struct hashmap_entry e;
30 char path[FLEX_ARRAY];
31 };
32
33 static int path_hashmap_cmp(const void *cmp_data,
34 const void *entry,
35 const void *entry_or_key,
36 const void *keydata)
37 {
38 const struct path_hashmap_entry *a = entry;
39 const struct path_hashmap_entry *b = entry_or_key;
40 const char *key = keydata;
41
42 if (ignore_case)
43 return strcasecmp(a->path, key ? key : b->path);
44 else
45 return strcmp(a->path, key ? key : b->path);
46 }
47
48 static unsigned int path_hash(const char *path)
49 {
50 return ignore_case ? strihash(path) : strhash(path);
51 }
52
53 static void flush_output(struct merge_options *o)
54 {
55 if (o->buffer_output < 2 && o->obuf.len) {
56 fputs(o->obuf.buf, stdout);
57 strbuf_reset(&o->obuf);
58 }
59 }
60
61 static int err(struct merge_options *o, const char *err, ...)
62 {
63 va_list params;
64
65 if (o->buffer_output < 2)
66 flush_output(o);
67 else {
68 strbuf_complete(&o->obuf, '\n');
69 strbuf_addstr(&o->obuf, "error: ");
70 }
71 va_start(params, err);
72 strbuf_vaddf(&o->obuf, err, params);
73 va_end(params);
74 if (o->buffer_output > 1)
75 strbuf_addch(&o->obuf, '\n');
76 else {
77 error("%s", o->obuf.buf);
78 strbuf_reset(&o->obuf);
79 }
80
81 return -1;
82 }
83
84 static struct tree *shift_tree_object(struct tree *one, struct tree *two,
85 const char *subtree_shift)
86 {
87 struct object_id shifted;
88
89 if (!*subtree_shift) {
90 shift_tree(&one->object.oid, &two->object.oid, &shifted, 0);
91 } else {
92 shift_tree_by(&one->object.oid, &two->object.oid, &shifted,
93 subtree_shift);
94 }
95 if (!oidcmp(&two->object.oid, &shifted))
96 return two;
97 return lookup_tree(&shifted);
98 }
99
100 static struct commit *make_virtual_commit(struct tree *tree, const char *comment)
101 {
102 struct commit *commit = alloc_commit_node(the_repository);
103
104 set_merge_remote_desc(commit, comment, (struct object *)commit);
105 commit->tree = tree;
106 commit->object.parsed = 1;
107 return commit;
108 }
109
110 /*
111 * Since we use get_tree_entry(), which does not put the read object into
112 * the object pool, we cannot rely on a == b.
113 */
114 static int oid_eq(const struct object_id *a, const struct object_id *b)
115 {
116 if (!a && !b)
117 return 2;
118 return a && b && oidcmp(a, b) == 0;
119 }
120
121 enum rename_type {
122 RENAME_NORMAL = 0,
123 RENAME_DELETE,
124 RENAME_ONE_FILE_TO_ONE,
125 RENAME_ONE_FILE_TO_TWO,
126 RENAME_TWO_FILES_TO_ONE
127 };
128
129 struct rename_conflict_info {
130 enum rename_type rename_type;
131 struct diff_filepair *pair1;
132 struct diff_filepair *pair2;
133 const char *branch1;
134 const char *branch2;
135 struct stage_data *dst_entry1;
136 struct stage_data *dst_entry2;
137 struct diff_filespec ren1_other;
138 struct diff_filespec ren2_other;
139 };
140
141 /*
142 * Since we want to write the index eventually, we cannot reuse the index
143 * for these (temporary) data.
144 */
145 struct stage_data {
146 struct {
147 unsigned mode;
148 struct object_id oid;
149 } stages[4];
150 struct rename_conflict_info *rename_conflict_info;
151 unsigned processed:1;
152 };
153
154 static inline void setup_rename_conflict_info(enum rename_type rename_type,
155 struct diff_filepair *pair1,
156 struct diff_filepair *pair2,
157 const char *branch1,
158 const char *branch2,
159 struct stage_data *dst_entry1,
160 struct stage_data *dst_entry2,
161 struct merge_options *o,
162 struct stage_data *src_entry1,
163 struct stage_data *src_entry2)
164 {
165 struct rename_conflict_info *ci = xcalloc(1, sizeof(struct rename_conflict_info));
166 ci->rename_type = rename_type;
167 ci->pair1 = pair1;
168 ci->branch1 = branch1;
169 ci->branch2 = branch2;
170
171 ci->dst_entry1 = dst_entry1;
172 dst_entry1->rename_conflict_info = ci;
173 dst_entry1->processed = 0;
174
175 assert(!pair2 == !dst_entry2);
176 if (dst_entry2) {
177 ci->dst_entry2 = dst_entry2;
178 ci->pair2 = pair2;
179 dst_entry2->rename_conflict_info = ci;
180 }
181
182 if (rename_type == RENAME_TWO_FILES_TO_ONE) {
183 /*
184 * For each rename, there could have been
185 * modifications on the side of history where that
186 * file was not renamed.
187 */
188 int ostage1 = o->branch1 == branch1 ? 3 : 2;
189 int ostage2 = ostage1 ^ 1;
190
191 ci->ren1_other.path = pair1->one->path;
192 oidcpy(&ci->ren1_other.oid, &src_entry1->stages[ostage1].oid);
193 ci->ren1_other.mode = src_entry1->stages[ostage1].mode;
194
195 ci->ren2_other.path = pair2->one->path;
196 oidcpy(&ci->ren2_other.oid, &src_entry2->stages[ostage2].oid);
197 ci->ren2_other.mode = src_entry2->stages[ostage2].mode;
198 }
199 }
200
201 static int show(struct merge_options *o, int v)
202 {
203 return (!o->call_depth && o->verbosity >= v) || o->verbosity >= 5;
204 }
205
206 __attribute__((format (printf, 3, 4)))
207 static void output(struct merge_options *o, int v, const char *fmt, ...)
208 {
209 va_list ap;
210
211 if (!show(o, v))
212 return;
213
214 strbuf_addchars(&o->obuf, ' ', o->call_depth * 2);
215
216 va_start(ap, fmt);
217 strbuf_vaddf(&o->obuf, fmt, ap);
218 va_end(ap);
219
220 strbuf_addch(&o->obuf, '\n');
221 if (!o->buffer_output)
222 flush_output(o);
223 }
224
225 static void output_commit_title(struct merge_options *o, struct commit *commit)
226 {
227 strbuf_addchars(&o->obuf, ' ', o->call_depth * 2);
228 if (commit->util)
229 strbuf_addf(&o->obuf, "virtual %s\n",
230 merge_remote_util(commit)->name);
231 else {
232 strbuf_add_unique_abbrev(&o->obuf, &commit->object.oid,
233 DEFAULT_ABBREV);
234 strbuf_addch(&o->obuf, ' ');
235 if (parse_commit(commit) != 0)
236 strbuf_addstr(&o->obuf, _("(bad commit)\n"));
237 else {
238 const char *title;
239 const char *msg = get_commit_buffer(commit, NULL);
240 int len = find_commit_subject(msg, &title);
241 if (len)
242 strbuf_addf(&o->obuf, "%.*s\n", len, title);
243 unuse_commit_buffer(commit, msg);
244 }
245 }
246 flush_output(o);
247 }
248
249 static int add_cacheinfo(struct merge_options *o,
250 unsigned int mode, const struct object_id *oid,
251 const char *path, int stage, int refresh, int options)
252 {
253 struct cache_entry *ce;
254 int ret;
255
256 ce = make_cache_entry(mode, oid ? oid->hash : null_sha1, path, stage, 0);
257 if (!ce)
258 return err(o, _("addinfo_cache failed for path '%s'"), path);
259
260 ret = add_cache_entry(ce, options);
261 if (refresh) {
262 struct cache_entry *nce;
263
264 nce = refresh_cache_entry(ce, CE_MATCH_REFRESH | CE_MATCH_IGNORE_MISSING);
265 if (!nce)
266 return err(o, _("addinfo_cache failed for path '%s'"), path);
267 if (nce != ce)
268 ret = add_cache_entry(nce, options);
269 }
270 return ret;
271 }
272
273 static void init_tree_desc_from_tree(struct tree_desc *desc, struct tree *tree)
274 {
275 parse_tree(tree);
276 init_tree_desc(desc, tree->buffer, tree->size);
277 }
278
279 static int git_merge_trees(int index_only,
280 struct tree *common,
281 struct tree *head,
282 struct tree *merge)
283 {
284 int rc;
285 struct tree_desc t[3];
286 struct unpack_trees_options opts;
287
288 memset(&opts, 0, sizeof(opts));
289 if (index_only)
290 opts.index_only = 1;
291 else
292 opts.update = 1;
293 opts.merge = 1;
294 opts.head_idx = 2;
295 opts.fn = threeway_merge;
296 opts.src_index = &the_index;
297 opts.dst_index = &the_index;
298 setup_unpack_trees_porcelain(&opts, "merge");
299
300 init_tree_desc_from_tree(t+0, common);
301 init_tree_desc_from_tree(t+1, head);
302 init_tree_desc_from_tree(t+2, merge);
303
304 rc = unpack_trees(3, t, &opts);
305 cache_tree_free(&active_cache_tree);
306 return rc;
307 }
308
309 struct tree *write_tree_from_memory(struct merge_options *o)
310 {
311 struct tree *result = NULL;
312
313 if (unmerged_cache()) {
314 int i;
315 fprintf(stderr, "BUG: There are unmerged index entries:\n");
316 for (i = 0; i < active_nr; i++) {
317 const struct cache_entry *ce = active_cache[i];
318 if (ce_stage(ce))
319 fprintf(stderr, "BUG: %d %.*s\n", ce_stage(ce),
320 (int)ce_namelen(ce), ce->name);
321 }
322 die("BUG: unmerged index entries in merge-recursive.c");
323 }
324
325 if (!active_cache_tree)
326 active_cache_tree = cache_tree();
327
328 if (!cache_tree_fully_valid(active_cache_tree) &&
329 cache_tree_update(&the_index, 0) < 0) {
330 err(o, _("error building trees"));
331 return NULL;
332 }
333
334 result = lookup_tree(&active_cache_tree->oid);
335
336 return result;
337 }
338
339 static int save_files_dirs(const struct object_id *oid,
340 struct strbuf *base, const char *path,
341 unsigned int mode, int stage, void *context)
342 {
343 struct path_hashmap_entry *entry;
344 int baselen = base->len;
345 struct merge_options *o = context;
346
347 strbuf_addstr(base, path);
348
349 FLEX_ALLOC_MEM(entry, path, base->buf, base->len);
350 hashmap_entry_init(entry, path_hash(entry->path));
351 hashmap_add(&o->current_file_dir_set, entry);
352
353 strbuf_setlen(base, baselen);
354 return (S_ISDIR(mode) ? READ_TREE_RECURSIVE : 0);
355 }
356
357 static void get_files_dirs(struct merge_options *o, struct tree *tree)
358 {
359 struct pathspec match_all;
360 memset(&match_all, 0, sizeof(match_all));
361 read_tree_recursive(tree, "", 0, 0, &match_all, save_files_dirs, o);
362 }
363
364 /*
365 * Returns an index_entry instance which doesn't have to correspond to
366 * a real cache entry in Git's index.
367 */
368 static struct stage_data *insert_stage_data(const char *path,
369 struct tree *o, struct tree *a, struct tree *b,
370 struct string_list *entries)
371 {
372 struct string_list_item *item;
373 struct stage_data *e = xcalloc(1, sizeof(struct stage_data));
374 get_tree_entry(&o->object.oid, path,
375 &e->stages[1].oid, &e->stages[1].mode);
376 get_tree_entry(&a->object.oid, path,
377 &e->stages[2].oid, &e->stages[2].mode);
378 get_tree_entry(&b->object.oid, path,
379 &e->stages[3].oid, &e->stages[3].mode);
380 item = string_list_insert(entries, path);
381 item->util = e;
382 return e;
383 }
384
385 /*
386 * Create a dictionary mapping file names to stage_data objects. The
387 * dictionary contains one entry for every path with a non-zero stage entry.
388 */
389 static struct string_list *get_unmerged(void)
390 {
391 struct string_list *unmerged = xcalloc(1, sizeof(struct string_list));
392 int i;
393
394 unmerged->strdup_strings = 1;
395
396 for (i = 0; i < active_nr; i++) {
397 struct string_list_item *item;
398 struct stage_data *e;
399 const struct cache_entry *ce = active_cache[i];
400 if (!ce_stage(ce))
401 continue;
402
403 item = string_list_lookup(unmerged, ce->name);
404 if (!item) {
405 item = string_list_insert(unmerged, ce->name);
406 item->util = xcalloc(1, sizeof(struct stage_data));
407 }
408 e = item->util;
409 e->stages[ce_stage(ce)].mode = ce->ce_mode;
410 oidcpy(&e->stages[ce_stage(ce)].oid, &ce->oid);
411 }
412
413 return unmerged;
414 }
415
416 static int string_list_df_name_compare(const char *one, const char *two)
417 {
418 int onelen = strlen(one);
419 int twolen = strlen(two);
420 /*
421 * Here we only care that entries for D/F conflicts are
422 * adjacent, in particular with the file of the D/F conflict
423 * appearing before files below the corresponding directory.
424 * The order of the rest of the list is irrelevant for us.
425 *
426 * To achieve this, we sort with df_name_compare and provide
427 * the mode S_IFDIR so that D/F conflicts will sort correctly.
428 * We use the mode S_IFDIR for everything else for simplicity,
429 * since in other cases any changes in their order due to
430 * sorting cause no problems for us.
431 */
432 int cmp = df_name_compare(one, onelen, S_IFDIR,
433 two, twolen, S_IFDIR);
434 /*
435 * Now that 'foo' and 'foo/bar' compare equal, we have to make sure
436 * that 'foo' comes before 'foo/bar'.
437 */
438 if (cmp)
439 return cmp;
440 return onelen - twolen;
441 }
442
443 static void record_df_conflict_files(struct merge_options *o,
444 struct string_list *entries)
445 {
446 /* If there is a D/F conflict and the file for such a conflict
447 * currently exist in the working tree, we want to allow it to be
448 * removed to make room for the corresponding directory if needed.
449 * The files underneath the directories of such D/F conflicts will
450 * be processed before the corresponding file involved in the D/F
451 * conflict. If the D/F directory ends up being removed by the
452 * merge, then we won't have to touch the D/F file. If the D/F
453 * directory needs to be written to the working copy, then the D/F
454 * file will simply be removed (in make_room_for_path()) to make
455 * room for the necessary paths. Note that if both the directory
456 * and the file need to be present, then the D/F file will be
457 * reinstated with a new unique name at the time it is processed.
458 */
459 struct string_list df_sorted_entries = STRING_LIST_INIT_NODUP;
460 const char *last_file = NULL;
461 int last_len = 0;
462 int i;
463
464 /*
465 * If we're merging merge-bases, we don't want to bother with
466 * any working directory changes.
467 */
468 if (o->call_depth)
469 return;
470
471 /* Ensure D/F conflicts are adjacent in the entries list. */
472 for (i = 0; i < entries->nr; i++) {
473 struct string_list_item *next = &entries->items[i];
474 string_list_append(&df_sorted_entries, next->string)->util =
475 next->util;
476 }
477 df_sorted_entries.cmp = string_list_df_name_compare;
478 string_list_sort(&df_sorted_entries);
479
480 string_list_clear(&o->df_conflict_file_set, 1);
481 for (i = 0; i < df_sorted_entries.nr; i++) {
482 const char *path = df_sorted_entries.items[i].string;
483 int len = strlen(path);
484 struct stage_data *e = df_sorted_entries.items[i].util;
485
486 /*
487 * Check if last_file & path correspond to a D/F conflict;
488 * i.e. whether path is last_file+'/'+<something>.
489 * If so, record that it's okay to remove last_file to make
490 * room for path and friends if needed.
491 */
492 if (last_file &&
493 len > last_len &&
494 memcmp(path, last_file, last_len) == 0 &&
495 path[last_len] == '/') {
496 string_list_insert(&o->df_conflict_file_set, last_file);
497 }
498
499 /*
500 * Determine whether path could exist as a file in the
501 * working directory as a possible D/F conflict. This
502 * will only occur when it exists in stage 2 as a
503 * file.
504 */
505 if (S_ISREG(e->stages[2].mode) || S_ISLNK(e->stages[2].mode)) {
506 last_file = path;
507 last_len = len;
508 } else {
509 last_file = NULL;
510 }
511 }
512 string_list_clear(&df_sorted_entries, 0);
513 }
514
515 struct rename {
516 struct diff_filepair *pair;
517 /*
518 * Purpose of src_entry and dst_entry:
519 *
520 * If 'before' is renamed to 'after' then src_entry will contain
521 * the versions of 'before' from the merge_base, HEAD, and MERGE in
522 * stages 1, 2, and 3; dst_entry will contain the respective
523 * versions of 'after' in corresponding locations. Thus, we have a
524 * total of six modes and oids, though some will be null. (Stage 0
525 * is ignored; we're interested in handling conflicts.)
526 *
527 * Since we don't turn on break-rewrites by default, neither
528 * src_entry nor dst_entry can have all three of their stages have
529 * non-null oids, meaning at most four of the six will be non-null.
530 * Also, since this is a rename, both src_entry and dst_entry will
531 * have at least one non-null oid, meaning at least two will be
532 * non-null. Of the six oids, a typical rename will have three be
533 * non-null. Only two implies a rename/delete, and four implies a
534 * rename/add.
535 */
536 struct stage_data *src_entry;
537 struct stage_data *dst_entry;
538 unsigned processed:1;
539 };
540
541 /*
542 * Get information of all renames which occurred between 'o_tree' and
543 * 'tree'. We need the three trees in the merge ('o_tree', 'a_tree' and
544 * 'b_tree') to be able to associate the correct cache entries with
545 * the rename information. 'tree' is always equal to either a_tree or b_tree.
546 */
547 static struct string_list *get_renames(struct merge_options *o,
548 struct tree *tree,
549 struct tree *o_tree,
550 struct tree *a_tree,
551 struct tree *b_tree,
552 struct string_list *entries)
553 {
554 int i;
555 struct string_list *renames;
556 struct diff_options opts;
557
558 renames = xcalloc(1, sizeof(struct string_list));
559 if (!o->detect_rename)
560 return renames;
561
562 diff_setup(&opts);
563 opts.flags.recursive = 1;
564 opts.flags.rename_empty = 0;
565 opts.detect_rename = DIFF_DETECT_RENAME;
566 opts.rename_limit = o->merge_rename_limit >= 0 ? o->merge_rename_limit :
567 o->diff_rename_limit >= 0 ? o->diff_rename_limit :
568 1000;
569 opts.rename_score = o->rename_score;
570 opts.show_rename_progress = o->show_rename_progress;
571 opts.output_format = DIFF_FORMAT_NO_OUTPUT;
572 diff_setup_done(&opts);
573 diff_tree_oid(&o_tree->object.oid, &tree->object.oid, "", &opts);
574 diffcore_std(&opts);
575 if (opts.needed_rename_limit > o->needed_rename_limit)
576 o->needed_rename_limit = opts.needed_rename_limit;
577 for (i = 0; i < diff_queued_diff.nr; ++i) {
578 struct string_list_item *item;
579 struct rename *re;
580 struct diff_filepair *pair = diff_queued_diff.queue[i];
581 if (pair->status != 'R') {
582 diff_free_filepair(pair);
583 continue;
584 }
585 re = xmalloc(sizeof(*re));
586 re->processed = 0;
587 re->pair = pair;
588 item = string_list_lookup(entries, re->pair->one->path);
589 if (!item)
590 re->src_entry = insert_stage_data(re->pair->one->path,
591 o_tree, a_tree, b_tree, entries);
592 else
593 re->src_entry = item->util;
594
595 item = string_list_lookup(entries, re->pair->two->path);
596 if (!item)
597 re->dst_entry = insert_stage_data(re->pair->two->path,
598 o_tree, a_tree, b_tree, entries);
599 else
600 re->dst_entry = item->util;
601 item = string_list_insert(renames, pair->one->path);
602 item->util = re;
603 }
604 opts.output_format = DIFF_FORMAT_NO_OUTPUT;
605 diff_queued_diff.nr = 0;
606 diff_flush(&opts);
607 return renames;
608 }
609
610 static int update_stages(struct merge_options *opt, const char *path,
611 const struct diff_filespec *o,
612 const struct diff_filespec *a,
613 const struct diff_filespec *b)
614 {
615
616 /*
617 * NOTE: It is usually a bad idea to call update_stages on a path
618 * before calling update_file on that same path, since it can
619 * sometimes lead to spurious "refusing to lose untracked file..."
620 * messages from update_file (via make_room_for path via
621 * would_lose_untracked). Instead, reverse the order of the calls
622 * (executing update_file first and then update_stages).
623 */
624 int clear = 1;
625 int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK;
626 if (clear)
627 if (remove_file_from_cache(path))
628 return -1;
629 if (o)
630 if (add_cacheinfo(opt, o->mode, &o->oid, path, 1, 0, options))
631 return -1;
632 if (a)
633 if (add_cacheinfo(opt, a->mode, &a->oid, path, 2, 0, options))
634 return -1;
635 if (b)
636 if (add_cacheinfo(opt, b->mode, &b->oid, path, 3, 0, options))
637 return -1;
638 return 0;
639 }
640
641 static void update_entry(struct stage_data *entry,
642 struct diff_filespec *o,
643 struct diff_filespec *a,
644 struct diff_filespec *b)
645 {
646 entry->processed = 0;
647 entry->stages[1].mode = o->mode;
648 entry->stages[2].mode = a->mode;
649 entry->stages[3].mode = b->mode;
650 oidcpy(&entry->stages[1].oid, &o->oid);
651 oidcpy(&entry->stages[2].oid, &a->oid);
652 oidcpy(&entry->stages[3].oid, &b->oid);
653 }
654
655 static int remove_file(struct merge_options *o, int clean,
656 const char *path, int no_wd)
657 {
658 int update_cache = o->call_depth || clean;
659 int update_working_directory = !o->call_depth && !no_wd;
660
661 if (update_cache) {
662 if (remove_file_from_cache(path))
663 return -1;
664 }
665 if (update_working_directory) {
666 if (ignore_case) {
667 struct cache_entry *ce;
668 ce = cache_file_exists(path, strlen(path), ignore_case);
669 if (ce && ce_stage(ce) == 0 && strcmp(path, ce->name))
670 return 0;
671 }
672 if (remove_path(path))
673 return -1;
674 }
675 return 0;
676 }
677
678 /* add a string to a strbuf, but converting "/" to "_" */
679 static void add_flattened_path(struct strbuf *out, const char *s)
680 {
681 size_t i = out->len;
682 strbuf_addstr(out, s);
683 for (; i < out->len; i++)
684 if (out->buf[i] == '/')
685 out->buf[i] = '_';
686 }
687
688 static char *unique_path(struct merge_options *o, const char *path, const char *branch)
689 {
690 struct path_hashmap_entry *entry;
691 struct strbuf newpath = STRBUF_INIT;
692 int suffix = 0;
693 size_t base_len;
694
695 strbuf_addf(&newpath, "%s~", path);
696 add_flattened_path(&newpath, branch);
697
698 base_len = newpath.len;
699 while (hashmap_get_from_hash(&o->current_file_dir_set,
700 path_hash(newpath.buf), newpath.buf) ||
701 (!o->call_depth && file_exists(newpath.buf))) {
702 strbuf_setlen(&newpath, base_len);
703 strbuf_addf(&newpath, "_%d", suffix++);
704 }
705
706 FLEX_ALLOC_MEM(entry, path, newpath.buf, newpath.len);
707 hashmap_entry_init(entry, path_hash(entry->path));
708 hashmap_add(&o->current_file_dir_set, entry);
709 return strbuf_detach(&newpath, NULL);
710 }
711
712 /**
713 * Check whether a directory in the index is in the way of an incoming
714 * file. Return 1 if so. If check_working_copy is non-zero, also
715 * check the working directory. If empty_ok is non-zero, also return
716 * 0 in the case where the working-tree dir exists but is empty.
717 */
718 static int dir_in_way(const char *path, int check_working_copy, int empty_ok)
719 {
720 int pos;
721 struct strbuf dirpath = STRBUF_INIT;
722 struct stat st;
723
724 strbuf_addstr(&dirpath, path);
725 strbuf_addch(&dirpath, '/');
726
727 pos = cache_name_pos(dirpath.buf, dirpath.len);
728
729 if (pos < 0)
730 pos = -1 - pos;
731 if (pos < active_nr &&
732 !strncmp(dirpath.buf, active_cache[pos]->name, dirpath.len)) {
733 strbuf_release(&dirpath);
734 return 1;
735 }
736
737 strbuf_release(&dirpath);
738 return check_working_copy && !lstat(path, &st) && S_ISDIR(st.st_mode) &&
739 !(empty_ok && is_empty_dir(path));
740 }
741
742 static int was_tracked(const char *path)
743 {
744 int pos = cache_name_pos(path, strlen(path));
745
746 if (0 <= pos)
747 /* we have been tracking this path */
748 return 1;
749
750 /*
751 * Look for an unmerged entry for the path,
752 * specifically stage #2, which would indicate
753 * that "our" side before the merge started
754 * had the path tracked (and resulted in a conflict).
755 */
756 for (pos = -1 - pos;
757 pos < active_nr && !strcmp(path, active_cache[pos]->name);
758 pos++)
759 if (ce_stage(active_cache[pos]) == 2)
760 return 1;
761 return 0;
762 }
763
764 static int would_lose_untracked(const char *path)
765 {
766 return !was_tracked(path) && file_exists(path);
767 }
768
769 static int make_room_for_path(struct merge_options *o, const char *path)
770 {
771 int status, i;
772 const char *msg = _("failed to create path '%s'%s");
773
774 /* Unlink any D/F conflict files that are in the way */
775 for (i = 0; i < o->df_conflict_file_set.nr; i++) {
776 const char *df_path = o->df_conflict_file_set.items[i].string;
777 size_t pathlen = strlen(path);
778 size_t df_pathlen = strlen(df_path);
779 if (df_pathlen < pathlen &&
780 path[df_pathlen] == '/' &&
781 strncmp(path, df_path, df_pathlen) == 0) {
782 output(o, 3,
783 _("Removing %s to make room for subdirectory\n"),
784 df_path);
785 unlink(df_path);
786 unsorted_string_list_delete_item(&o->df_conflict_file_set,
787 i, 0);
788 break;
789 }
790 }
791
792 /* Make sure leading directories are created */
793 status = safe_create_leading_directories_const(path);
794 if (status) {
795 if (status == SCLD_EXISTS)
796 /* something else exists */
797 return err(o, msg, path, _(": perhaps a D/F conflict?"));
798 return err(o, msg, path, "");
799 }
800
801 /*
802 * Do not unlink a file in the work tree if we are not
803 * tracking it.
804 */
805 if (would_lose_untracked(path))
806 return err(o, _("refusing to lose untracked file at '%s'"),
807 path);
808
809 /* Successful unlink is good.. */
810 if (!unlink(path))
811 return 0;
812 /* .. and so is no existing file */
813 if (errno == ENOENT)
814 return 0;
815 /* .. but not some other error (who really cares what?) */
816 return err(o, msg, path, _(": perhaps a D/F conflict?"));
817 }
818
819 static int update_file_flags(struct merge_options *o,
820 const struct object_id *oid,
821 unsigned mode,
822 const char *path,
823 int update_cache,
824 int update_wd)
825 {
826 int ret = 0;
827
828 if (o->call_depth)
829 update_wd = 0;
830
831 if (update_wd) {
832 enum object_type type;
833 void *buf;
834 unsigned long size;
835
836 if (S_ISGITLINK(mode)) {
837 /*
838 * We may later decide to recursively descend into
839 * the submodule directory and update its index
840 * and/or work tree, but we do not do that now.
841 */
842 update_wd = 0;
843 goto update_index;
844 }
845
846 buf = read_object_file(oid, &type, &size);
847 if (!buf)
848 return err(o, _("cannot read object %s '%s'"), oid_to_hex(oid), path);
849 if (type != OBJ_BLOB) {
850 ret = err(o, _("blob expected for %s '%s'"), oid_to_hex(oid), path);
851 goto free_buf;
852 }
853 if (S_ISREG(mode)) {
854 struct strbuf strbuf = STRBUF_INIT;
855 if (convert_to_working_tree(path, buf, size, &strbuf)) {
856 free(buf);
857 size = strbuf.len;
858 buf = strbuf_detach(&strbuf, NULL);
859 }
860 }
861
862 if (make_room_for_path(o, path) < 0) {
863 update_wd = 0;
864 goto free_buf;
865 }
866 if (S_ISREG(mode) || (!has_symlinks && S_ISLNK(mode))) {
867 int fd;
868 if (mode & 0100)
869 mode = 0777;
870 else
871 mode = 0666;
872 fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);
873 if (fd < 0) {
874 ret = err(o, _("failed to open '%s': %s"),
875 path, strerror(errno));
876 goto free_buf;
877 }
878 write_in_full(fd, buf, size);
879 close(fd);
880 } else if (S_ISLNK(mode)) {
881 char *lnk = xmemdupz(buf, size);
882 safe_create_leading_directories_const(path);
883 unlink(path);
884 if (symlink(lnk, path))
885 ret = err(o, _("failed to symlink '%s': %s"),
886 path, strerror(errno));
887 free(lnk);
888 } else
889 ret = err(o,
890 _("do not know what to do with %06o %s '%s'"),
891 mode, oid_to_hex(oid), path);
892 free_buf:
893 free(buf);
894 }
895 update_index:
896 if (!ret && update_cache)
897 add_cacheinfo(o, mode, oid, path, 0, update_wd, ADD_CACHE_OK_TO_ADD);
898 return ret;
899 }
900
901 static int update_file(struct merge_options *o,
902 int clean,
903 const struct object_id *oid,
904 unsigned mode,
905 const char *path)
906 {
907 return update_file_flags(o, oid, mode, path, o->call_depth || clean, !o->call_depth);
908 }
909
910 /* Low level file merging, update and removal */
911
912 struct merge_file_info {
913 struct object_id oid;
914 unsigned mode;
915 unsigned clean:1,
916 merge:1;
917 };
918
919 static int merge_3way(struct merge_options *o,
920 mmbuffer_t *result_buf,
921 const struct diff_filespec *one,
922 const struct diff_filespec *a,
923 const struct diff_filespec *b,
924 const char *branch1,
925 const char *branch2)
926 {
927 mmfile_t orig, src1, src2;
928 struct ll_merge_options ll_opts = {0};
929 char *base_name, *name1, *name2;
930 int merge_status;
931
932 ll_opts.renormalize = o->renormalize;
933 ll_opts.xdl_opts = o->xdl_opts;
934
935 if (o->call_depth) {
936 ll_opts.virtual_ancestor = 1;
937 ll_opts.variant = 0;
938 } else {
939 switch (o->recursive_variant) {
940 case MERGE_RECURSIVE_OURS:
941 ll_opts.variant = XDL_MERGE_FAVOR_OURS;
942 break;
943 case MERGE_RECURSIVE_THEIRS:
944 ll_opts.variant = XDL_MERGE_FAVOR_THEIRS;
945 break;
946 default:
947 ll_opts.variant = 0;
948 break;
949 }
950 }
951
952 if (strcmp(a->path, b->path) ||
953 (o->ancestor != NULL && strcmp(a->path, one->path) != 0)) {
954 base_name = o->ancestor == NULL ? NULL :
955 mkpathdup("%s:%s", o->ancestor, one->path);
956 name1 = mkpathdup("%s:%s", branch1, a->path);
957 name2 = mkpathdup("%s:%s", branch2, b->path);
958 } else {
959 base_name = o->ancestor == NULL ? NULL :
960 mkpathdup("%s", o->ancestor);
961 name1 = mkpathdup("%s", branch1);
962 name2 = mkpathdup("%s", branch2);
963 }
964
965 read_mmblob(&orig, &one->oid);
966 read_mmblob(&src1, &a->oid);
967 read_mmblob(&src2, &b->oid);
968
969 merge_status = ll_merge(result_buf, a->path, &orig, base_name,
970 &src1, name1, &src2, name2, &ll_opts);
971
972 free(base_name);
973 free(name1);
974 free(name2);
975 free(orig.ptr);
976 free(src1.ptr);
977 free(src2.ptr);
978 return merge_status;
979 }
980
981 static int merge_file_1(struct merge_options *o,
982 const struct diff_filespec *one,
983 const struct diff_filespec *a,
984 const struct diff_filespec *b,
985 const char *branch1,
986 const char *branch2,
987 struct merge_file_info *result)
988 {
989 result->merge = 0;
990 result->clean = 1;
991
992 if ((S_IFMT & a->mode) != (S_IFMT & b->mode)) {
993 result->clean = 0;
994 if (S_ISREG(a->mode)) {
995 result->mode = a->mode;
996 oidcpy(&result->oid, &a->oid);
997 } else {
998 result->mode = b->mode;
999 oidcpy(&result->oid, &b->oid);
1000 }
1001 } else {
1002 if (!oid_eq(&a->oid, &one->oid) && !oid_eq(&b->oid, &one->oid))
1003 result->merge = 1;
1004
1005 /*
1006 * Merge modes
1007 */
1008 if (a->mode == b->mode || a->mode == one->mode)
1009 result->mode = b->mode;
1010 else {
1011 result->mode = a->mode;
1012 if (b->mode != one->mode) {
1013 result->clean = 0;
1014 result->merge = 1;
1015 }
1016 }
1017
1018 if (oid_eq(&a->oid, &b->oid) || oid_eq(&a->oid, &one->oid))
1019 oidcpy(&result->oid, &b->oid);
1020 else if (oid_eq(&b->oid, &one->oid))
1021 oidcpy(&result->oid, &a->oid);
1022 else if (S_ISREG(a->mode)) {
1023 mmbuffer_t result_buf;
1024 int ret = 0, merge_status;
1025
1026 merge_status = merge_3way(o, &result_buf, one, a, b,
1027 branch1, branch2);
1028
1029 if ((merge_status < 0) || !result_buf.ptr)
1030 ret = err(o, _("Failed to execute internal merge"));
1031
1032 if (!ret &&
1033 write_object_file(result_buf.ptr, result_buf.size,
1034 blob_type, &result->oid))
1035 ret = err(o, _("Unable to add %s to database"),
1036 a->path);
1037
1038 free(result_buf.ptr);
1039 if (ret)
1040 return ret;
1041 result->clean = (merge_status == 0);
1042 } else if (S_ISGITLINK(a->mode)) {
1043 result->clean = merge_submodule(&result->oid,
1044 one->path,
1045 &one->oid,
1046 &a->oid,
1047 &b->oid,
1048 !o->call_depth);
1049 } else if (S_ISLNK(a->mode)) {
1050 switch (o->recursive_variant) {
1051 case MERGE_RECURSIVE_NORMAL:
1052 oidcpy(&result->oid, &a->oid);
1053 if (!oid_eq(&a->oid, &b->oid))
1054 result->clean = 0;
1055 break;
1056 case MERGE_RECURSIVE_OURS:
1057 oidcpy(&result->oid, &a->oid);
1058 break;
1059 case MERGE_RECURSIVE_THEIRS:
1060 oidcpy(&result->oid, &b->oid);
1061 break;
1062 }
1063 } else
1064 die("BUG: unsupported object type in the tree");
1065 }
1066
1067 return 0;
1068 }
1069
1070 static int merge_file_special_markers(struct merge_options *o,
1071 const struct diff_filespec *one,
1072 const struct diff_filespec *a,
1073 const struct diff_filespec *b,
1074 const char *branch1,
1075 const char *filename1,
1076 const char *branch2,
1077 const char *filename2,
1078 struct merge_file_info *mfi)
1079 {
1080 char *side1 = NULL;
1081 char *side2 = NULL;
1082 int ret;
1083
1084 if (filename1)
1085 side1 = xstrfmt("%s:%s", branch1, filename1);
1086 if (filename2)
1087 side2 = xstrfmt("%s:%s", branch2, filename2);
1088
1089 ret = merge_file_1(o, one, a, b,
1090 side1 ? side1 : branch1,
1091 side2 ? side2 : branch2, mfi);
1092 free(side1);
1093 free(side2);
1094 return ret;
1095 }
1096
1097 static int merge_file_one(struct merge_options *o,
1098 const char *path,
1099 const struct object_id *o_oid, int o_mode,
1100 const struct object_id *a_oid, int a_mode,
1101 const struct object_id *b_oid, int b_mode,
1102 const char *branch1,
1103 const char *branch2,
1104 struct merge_file_info *mfi)
1105 {
1106 struct diff_filespec one, a, b;
1107
1108 one.path = a.path = b.path = (char *)path;
1109 oidcpy(&one.oid, o_oid);
1110 one.mode = o_mode;
1111 oidcpy(&a.oid, a_oid);
1112 a.mode = a_mode;
1113 oidcpy(&b.oid, b_oid);
1114 b.mode = b_mode;
1115 return merge_file_1(o, &one, &a, &b, branch1, branch2, mfi);
1116 }
1117
1118 static int handle_change_delete(struct merge_options *o,
1119 const char *path, const char *old_path,
1120 const struct object_id *o_oid, int o_mode,
1121 const struct object_id *changed_oid,
1122 int changed_mode,
1123 const char *change_branch,
1124 const char *delete_branch,
1125 const char *change, const char *change_past)
1126 {
1127 char *alt_path = NULL;
1128 const char *update_path = path;
1129 int ret = 0;
1130
1131 if (dir_in_way(path, !o->call_depth, 0)) {
1132 update_path = alt_path = unique_path(o, path, change_branch);
1133 }
1134
1135 if (o->call_depth) {
1136 /*
1137 * We cannot arbitrarily accept either a_sha or b_sha as
1138 * correct; since there is no true "middle point" between
1139 * them, simply reuse the base version for virtual merge base.
1140 */
1141 ret = remove_file_from_cache(path);
1142 if (!ret)
1143 ret = update_file(o, 0, o_oid, o_mode, update_path);
1144 } else {
1145 if (!alt_path) {
1146 if (!old_path) {
1147 output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "
1148 "and %s in %s. Version %s of %s left in tree."),
1149 change, path, delete_branch, change_past,
1150 change_branch, change_branch, path);
1151 } else {
1152 output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "
1153 "and %s to %s in %s. Version %s of %s left in tree."),
1154 change, old_path, delete_branch, change_past, path,
1155 change_branch, change_branch, path);
1156 }
1157 } else {
1158 if (!old_path) {
1159 output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "
1160 "and %s in %s. Version %s of %s left in tree at %s."),
1161 change, path, delete_branch, change_past,
1162 change_branch, change_branch, path, alt_path);
1163 } else {
1164 output(o, 1, _("CONFLICT (%s/delete): %s deleted in %s "
1165 "and %s to %s in %s. Version %s of %s left in tree at %s."),
1166 change, old_path, delete_branch, change_past, path,
1167 change_branch, change_branch, path, alt_path);
1168 }
1169 }
1170 /*
1171 * No need to call update_file() on path when change_branch ==
1172 * o->branch1 && !alt_path, since that would needlessly touch
1173 * path. We could call update_file_flags() with update_cache=0
1174 * and update_wd=0, but that's a no-op.
1175 */
1176 if (change_branch != o->branch1 || alt_path)
1177 ret = update_file(o, 0, changed_oid, changed_mode, update_path);
1178 }
1179 free(alt_path);
1180
1181 return ret;
1182 }
1183
1184 static int conflict_rename_delete(struct merge_options *o,
1185 struct diff_filepair *pair,
1186 const char *rename_branch,
1187 const char *delete_branch)
1188 {
1189 const struct diff_filespec *orig = pair->one;
1190 const struct diff_filespec *dest = pair->two;
1191
1192 if (handle_change_delete(o,
1193 o->call_depth ? orig->path : dest->path,
1194 o->call_depth ? NULL : orig->path,
1195 &orig->oid, orig->mode,
1196 &dest->oid, dest->mode,
1197 rename_branch, delete_branch,
1198 _("rename"), _("renamed")))
1199 return -1;
1200
1201 if (o->call_depth)
1202 return remove_file_from_cache(dest->path);
1203 else
1204 return update_stages(o, dest->path, NULL,
1205 rename_branch == o->branch1 ? dest : NULL,
1206 rename_branch == o->branch1 ? NULL : dest);
1207 }
1208
1209 static struct diff_filespec *filespec_from_entry(struct diff_filespec *target,
1210 struct stage_data *entry,
1211 int stage)
1212 {
1213 struct object_id *oid = &entry->stages[stage].oid;
1214 unsigned mode = entry->stages[stage].mode;
1215 if (mode == 0 || is_null_oid(oid))
1216 return NULL;
1217 oidcpy(&target->oid, oid);
1218 target->mode = mode;
1219 return target;
1220 }
1221
1222 static int handle_file(struct merge_options *o,
1223 struct diff_filespec *rename,
1224 int stage,
1225 struct rename_conflict_info *ci)
1226 {
1227 char *dst_name = rename->path;
1228 struct stage_data *dst_entry;
1229 const char *cur_branch, *other_branch;
1230 struct diff_filespec other;
1231 struct diff_filespec *add;
1232 int ret;
1233
1234 if (stage == 2) {
1235 dst_entry = ci->dst_entry1;
1236 cur_branch = ci->branch1;
1237 other_branch = ci->branch2;
1238 } else {
1239 dst_entry = ci->dst_entry2;
1240 cur_branch = ci->branch2;
1241 other_branch = ci->branch1;
1242 }
1243
1244 add = filespec_from_entry(&other, dst_entry, stage ^ 1);
1245 if (add) {
1246 char *add_name = unique_path(o, rename->path, other_branch);
1247 if (update_file(o, 0, &add->oid, add->mode, add_name))
1248 return -1;
1249
1250 remove_file(o, 0, rename->path, 0);
1251 dst_name = unique_path(o, rename->path, cur_branch);
1252 } else {
1253 if (dir_in_way(rename->path, !o->call_depth, 0)) {
1254 dst_name = unique_path(o, rename->path, cur_branch);
1255 output(o, 1, _("%s is a directory in %s adding as %s instead"),
1256 rename->path, other_branch, dst_name);
1257 }
1258 }
1259 if ((ret = update_file(o, 0, &rename->oid, rename->mode, dst_name)))
1260 ; /* fall through, do allow dst_name to be released */
1261 else if (stage == 2)
1262 ret = update_stages(o, rename->path, NULL, rename, add);
1263 else
1264 ret = update_stages(o, rename->path, NULL, add, rename);
1265
1266 if (dst_name != rename->path)
1267 free(dst_name);
1268
1269 return ret;
1270 }
1271
1272 static int conflict_rename_rename_1to2(struct merge_options *o,
1273 struct rename_conflict_info *ci)
1274 {
1275 /* One file was renamed in both branches, but to different names. */
1276 struct diff_filespec *one = ci->pair1->one;
1277 struct diff_filespec *a = ci->pair1->two;
1278 struct diff_filespec *b = ci->pair2->two;
1279
1280 output(o, 1, _("CONFLICT (rename/rename): "
1281 "Rename \"%s\"->\"%s\" in branch \"%s\" "
1282 "rename \"%s\"->\"%s\" in \"%s\"%s"),
1283 one->path, a->path, ci->branch1,
1284 one->path, b->path, ci->branch2,
1285 o->call_depth ? _(" (left unresolved)") : "");
1286 if (o->call_depth) {
1287 struct merge_file_info mfi;
1288 struct diff_filespec other;
1289 struct diff_filespec *add;
1290 if (merge_file_one(o, one->path,
1291 &one->oid, one->mode,
1292 &a->oid, a->mode,
1293 &b->oid, b->mode,
1294 ci->branch1, ci->branch2, &mfi))
1295 return -1;
1296
1297 /*
1298 * FIXME: For rename/add-source conflicts (if we could detect
1299 * such), this is wrong. We should instead find a unique
1300 * pathname and then either rename the add-source file to that
1301 * unique path, or use that unique path instead of src here.
1302 */
1303 if (update_file(o, 0, &mfi.oid, mfi.mode, one->path))
1304 return -1;
1305
1306 /*
1307 * Above, we put the merged content at the merge-base's
1308 * path. Now we usually need to delete both a->path and
1309 * b->path. However, the rename on each side of the merge
1310 * could also be involved in a rename/add conflict. In
1311 * such cases, we should keep the added file around,
1312 * resolving the conflict at that path in its favor.
1313 */
1314 add = filespec_from_entry(&other, ci->dst_entry1, 2 ^ 1);
1315 if (add) {
1316 if (update_file(o, 0, &add->oid, add->mode, a->path))
1317 return -1;
1318 }
1319 else
1320 remove_file_from_cache(a->path);
1321 add = filespec_from_entry(&other, ci->dst_entry2, 3 ^ 1);
1322 if (add) {
1323 if (update_file(o, 0, &add->oid, add->mode, b->path))
1324 return -1;
1325 }
1326 else
1327 remove_file_from_cache(b->path);
1328 } else if (handle_file(o, a, 2, ci) || handle_file(o, b, 3, ci))
1329 return -1;
1330
1331 return 0;
1332 }
1333
1334 static int conflict_rename_rename_2to1(struct merge_options *o,
1335 struct rename_conflict_info *ci)
1336 {
1337 /* Two files, a & b, were renamed to the same thing, c. */
1338 struct diff_filespec *a = ci->pair1->one;
1339 struct diff_filespec *b = ci->pair2->one;
1340 struct diff_filespec *c1 = ci->pair1->two;
1341 struct diff_filespec *c2 = ci->pair2->two;
1342 char *path = c1->path; /* == c2->path */
1343 struct merge_file_info mfi_c1;
1344 struct merge_file_info mfi_c2;
1345 int ret;
1346
1347 output(o, 1, _("CONFLICT (rename/rename): "
1348 "Rename %s->%s in %s. "
1349 "Rename %s->%s in %s"),
1350 a->path, c1->path, ci->branch1,
1351 b->path, c2->path, ci->branch2);
1352
1353 remove_file(o, 1, a->path, o->call_depth || would_lose_untracked(a->path));
1354 remove_file(o, 1, b->path, o->call_depth || would_lose_untracked(b->path));
1355
1356 if (merge_file_special_markers(o, a, c1, &ci->ren1_other,
1357 o->branch1, c1->path,
1358 o->branch2, ci->ren1_other.path, &mfi_c1) ||
1359 merge_file_special_markers(o, b, &ci->ren2_other, c2,
1360 o->branch1, ci->ren2_other.path,
1361 o->branch2, c2->path, &mfi_c2))
1362 return -1;
1363
1364 if (o->call_depth) {
1365 /*
1366 * If mfi_c1.clean && mfi_c2.clean, then it might make
1367 * sense to do a two-way merge of those results. But, I
1368 * think in all cases, it makes sense to have the virtual
1369 * merge base just undo the renames; they can be detected
1370 * again later for the non-recursive merge.
1371 */
1372 remove_file(o, 0, path, 0);
1373 ret = update_file(o, 0, &mfi_c1.oid, mfi_c1.mode, a->path);
1374 if (!ret)
1375 ret = update_file(o, 0, &mfi_c2.oid, mfi_c2.mode,
1376 b->path);
1377 } else {
1378 char *new_path1 = unique_path(o, path, ci->branch1);
1379 char *new_path2 = unique_path(o, path, ci->branch2);
1380 output(o, 1, _("Renaming %s to %s and %s to %s instead"),
1381 a->path, new_path1, b->path, new_path2);
1382 remove_file(o, 0, path, 0);
1383 ret = update_file(o, 0, &mfi_c1.oid, mfi_c1.mode, new_path1);
1384 if (!ret)
1385 ret = update_file(o, 0, &mfi_c2.oid, mfi_c2.mode,
1386 new_path2);
1387 free(new_path2);
1388 free(new_path1);
1389 }
1390
1391 return ret;
1392 }
1393
1394 static int process_renames(struct merge_options *o,
1395 struct string_list *a_renames,
1396 struct string_list *b_renames)
1397 {
1398 int clean_merge = 1, i, j;
1399 struct string_list a_by_dst = STRING_LIST_INIT_NODUP;
1400 struct string_list b_by_dst = STRING_LIST_INIT_NODUP;
1401 const struct rename *sre;
1402
1403 for (i = 0; i < a_renames->nr; i++) {
1404 sre = a_renames->items[i].util;
1405 string_list_insert(&a_by_dst, sre->pair->two->path)->util
1406 = (void *)sre;
1407 }
1408 for (i = 0; i < b_renames->nr; i++) {
1409 sre = b_renames->items[i].util;
1410 string_list_insert(&b_by_dst, sre->pair->two->path)->util
1411 = (void *)sre;
1412 }
1413
1414 for (i = 0, j = 0; i < a_renames->nr || j < b_renames->nr;) {
1415 struct string_list *renames1, *renames2Dst;
1416 struct rename *ren1 = NULL, *ren2 = NULL;
1417 const char *branch1, *branch2;
1418 const char *ren1_src, *ren1_dst;
1419 struct string_list_item *lookup;
1420
1421 if (i >= a_renames->nr) {
1422 ren2 = b_renames->items[j++].util;
1423 } else if (j >= b_renames->nr) {
1424 ren1 = a_renames->items[i++].util;
1425 } else {
1426 int compare = strcmp(a_renames->items[i].string,
1427 b_renames->items[j].string);
1428 if (compare <= 0)
1429 ren1 = a_renames->items[i++].util;
1430 if (compare >= 0)
1431 ren2 = b_renames->items[j++].util;
1432 }
1433
1434 /* TODO: refactor, so that 1/2 are not needed */
1435 if (ren1) {
1436 renames1 = a_renames;
1437 renames2Dst = &b_by_dst;
1438 branch1 = o->branch1;
1439 branch2 = o->branch2;
1440 } else {
1441 renames1 = b_renames;
1442 renames2Dst = &a_by_dst;
1443 branch1 = o->branch2;
1444 branch2 = o->branch1;
1445 SWAP(ren2, ren1);
1446 }
1447
1448 if (ren1->processed)
1449 continue;
1450 ren1->processed = 1;
1451 ren1->dst_entry->processed = 1;
1452 /* BUG: We should only mark src_entry as processed if we
1453 * are not dealing with a rename + add-source case.
1454 */
1455 ren1->src_entry->processed = 1;
1456
1457 ren1_src = ren1->pair->one->path;
1458 ren1_dst = ren1->pair->two->path;
1459
1460 if (ren2) {
1461 /* One file renamed on both sides */
1462 const char *ren2_src = ren2->pair->one->path;
1463 const char *ren2_dst = ren2->pair->two->path;
1464 enum rename_type rename_type;
1465 if (strcmp(ren1_src, ren2_src) != 0)
1466 die("BUG: ren1_src != ren2_src");
1467 ren2->dst_entry->processed = 1;
1468 ren2->processed = 1;
1469 if (strcmp(ren1_dst, ren2_dst) != 0) {
1470 rename_type = RENAME_ONE_FILE_TO_TWO;
1471 clean_merge = 0;
1472 } else {
1473 rename_type = RENAME_ONE_FILE_TO_ONE;
1474 /* BUG: We should only remove ren1_src in
1475 * the base stage (think of rename +
1476 * add-source cases).
1477 */
1478 remove_file(o, 1, ren1_src, 1);
1479 update_entry(ren1->dst_entry,
1480 ren1->pair->one,
1481 ren1->pair->two,
1482 ren2->pair->two);
1483 }
1484 setup_rename_conflict_info(rename_type,
1485 ren1->pair,
1486 ren2->pair,
1487 branch1,
1488 branch2,
1489 ren1->dst_entry,
1490 ren2->dst_entry,
1491 o,
1492 NULL,
1493 NULL);
1494 } else if ((lookup = string_list_lookup(renames2Dst, ren1_dst))) {
1495 /* Two different files renamed to the same thing */
1496 char *ren2_dst;
1497 ren2 = lookup->util;
1498 ren2_dst = ren2->pair->two->path;
1499 if (strcmp(ren1_dst, ren2_dst) != 0)
1500 die("BUG: ren1_dst != ren2_dst");
1501
1502 clean_merge = 0;
1503 ren2->processed = 1;
1504 /*
1505 * BUG: We should only mark src_entry as processed
1506 * if we are not dealing with a rename + add-source
1507 * case.
1508 */
1509 ren2->src_entry->processed = 1;
1510
1511 setup_rename_conflict_info(RENAME_TWO_FILES_TO_ONE,
1512 ren1->pair,
1513 ren2->pair,
1514 branch1,
1515 branch2,
1516 ren1->dst_entry,
1517 ren2->dst_entry,
1518 o,
1519 ren1->src_entry,
1520 ren2->src_entry);
1521
1522 } else {
1523 /* Renamed in 1, maybe changed in 2 */
1524 /* we only use sha1 and mode of these */
1525 struct diff_filespec src_other, dst_other;
1526 int try_merge;
1527
1528 /*
1529 * unpack_trees loads entries from common-commit
1530 * into stage 1, from head-commit into stage 2, and
1531 * from merge-commit into stage 3. We keep track
1532 * of which side corresponds to the rename.
1533 */
1534 int renamed_stage = a_renames == renames1 ? 2 : 3;
1535 int other_stage = a_renames == renames1 ? 3 : 2;
1536
1537 /* BUG: We should only remove ren1_src in the base
1538 * stage and in other_stage (think of rename +
1539 * add-source case).
1540 */
1541 remove_file(o, 1, ren1_src,
1542 renamed_stage == 2 || !was_tracked(ren1_src));
1543
1544 oidcpy(&src_other.oid,
1545 &ren1->src_entry->stages[other_stage].oid);
1546 src_other.mode = ren1->src_entry->stages[other_stage].mode;
1547 oidcpy(&dst_other.oid,
1548 &ren1->dst_entry->stages[other_stage].oid);
1549 dst_other.mode = ren1->dst_entry->stages[other_stage].mode;
1550 try_merge = 0;
1551
1552 if (oid_eq(&src_other.oid, &null_oid)) {
1553 setup_rename_conflict_info(RENAME_DELETE,
1554 ren1->pair,
1555 NULL,
1556 branch1,
1557 branch2,
1558 ren1->dst_entry,
1559 NULL,
1560 o,
1561 NULL,
1562 NULL);
1563 } else if ((dst_other.mode == ren1->pair->two->mode) &&
1564 oid_eq(&dst_other.oid, &ren1->pair->two->oid)) {
1565 /*
1566 * Added file on the other side identical to
1567 * the file being renamed: clean merge.
1568 * Also, there is no need to overwrite the
1569 * file already in the working copy, so call
1570 * update_file_flags() instead of
1571 * update_file().
1572 */
1573 if (update_file_flags(o,
1574 &ren1->pair->two->oid,
1575 ren1->pair->two->mode,
1576 ren1_dst,
1577 1, /* update_cache */
1578 0 /* update_wd */))
1579 clean_merge = -1;
1580 } else if (!oid_eq(&dst_other.oid, &null_oid)) {
1581 clean_merge = 0;
1582 try_merge = 1;
1583 output(o, 1, _("CONFLICT (rename/add): Rename %s->%s in %s. "
1584 "%s added in %s"),
1585 ren1_src, ren1_dst, branch1,
1586 ren1_dst, branch2);
1587 if (o->call_depth) {
1588 struct merge_file_info mfi;
1589 if (merge_file_one(o, ren1_dst, &null_oid, 0,
1590 &ren1->pair->two->oid,
1591 ren1->pair->two->mode,
1592 &dst_other.oid,
1593 dst_other.mode,
1594 branch1, branch2, &mfi)) {
1595 clean_merge = -1;
1596 goto cleanup_and_return;
1597 }
1598 output(o, 1, _("Adding merged %s"), ren1_dst);
1599 if (update_file(o, 0, &mfi.oid,
1600 mfi.mode, ren1_dst))
1601 clean_merge = -1;
1602 try_merge = 0;
1603 } else {
1604 char *new_path = unique_path(o, ren1_dst, branch2);
1605 output(o, 1, _("Adding as %s instead"), new_path);
1606 if (update_file(o, 0, &dst_other.oid,
1607 dst_other.mode, new_path))
1608 clean_merge = -1;
1609 free(new_path);
1610 }
1611 } else
1612 try_merge = 1;
1613
1614 if (clean_merge < 0)
1615 goto cleanup_and_return;
1616 if (try_merge) {
1617 struct diff_filespec *one, *a, *b;
1618 src_other.path = (char *)ren1_src;
1619
1620 one = ren1->pair->one;
1621 if (a_renames == renames1) {
1622 a = ren1->pair->two;
1623 b = &src_other;
1624 } else {
1625 b = ren1->pair->two;
1626 a = &src_other;
1627 }
1628 update_entry(ren1->dst_entry, one, a, b);
1629 setup_rename_conflict_info(RENAME_NORMAL,
1630 ren1->pair,
1631 NULL,
1632 branch1,
1633 NULL,
1634 ren1->dst_entry,
1635 NULL,
1636 o,
1637 NULL,
1638 NULL);
1639 }
1640 }
1641 }
1642 cleanup_and_return:
1643 string_list_clear(&a_by_dst, 0);
1644 string_list_clear(&b_by_dst, 0);
1645
1646 return clean_merge;
1647 }
1648
1649 static struct object_id *stage_oid(const struct object_id *oid, unsigned mode)
1650 {
1651 return (is_null_oid(oid) || mode == 0) ? NULL: (struct object_id *)oid;
1652 }
1653
1654 static int read_oid_strbuf(struct merge_options *o,
1655 const struct object_id *oid, struct strbuf *dst)
1656 {
1657 void *buf;
1658 enum object_type type;
1659 unsigned long size;
1660 buf = read_object_file(oid, &type, &size);
1661 if (!buf)
1662 return err(o, _("cannot read object %s"), oid_to_hex(oid));
1663 if (type != OBJ_BLOB) {
1664 free(buf);
1665 return err(o, _("object %s is not a blob"), oid_to_hex(oid));
1666 }
1667 strbuf_attach(dst, buf, size, size + 1);
1668 return 0;
1669 }
1670
1671 static int blob_unchanged(struct merge_options *opt,
1672 const struct object_id *o_oid,
1673 unsigned o_mode,
1674 const struct object_id *a_oid,
1675 unsigned a_mode,
1676 int renormalize, const char *path)
1677 {
1678 struct strbuf o = STRBUF_INIT;
1679 struct strbuf a = STRBUF_INIT;
1680 int ret = 0; /* assume changed for safety */
1681
1682 if (a_mode != o_mode)
1683 return 0;
1684 if (oid_eq(o_oid, a_oid))
1685 return 1;
1686 if (!renormalize)
1687 return 0;
1688
1689 assert(o_oid && a_oid);
1690 if (read_oid_strbuf(opt, o_oid, &o) || read_oid_strbuf(opt, a_oid, &a))
1691 goto error_return;
1692 /*
1693 * Note: binary | is used so that both renormalizations are
1694 * performed. Comparison can be skipped if both files are
1695 * unchanged since their sha1s have already been compared.
1696 */
1697 if (renormalize_buffer(&the_index, path, o.buf, o.len, &o) |
1698 renormalize_buffer(&the_index, path, a.buf, a.len, &a))
1699 ret = (o.len == a.len && !memcmp(o.buf, a.buf, o.len));
1700
1701 error_return:
1702 strbuf_release(&o);
1703 strbuf_release(&a);
1704 return ret;
1705 }
1706
1707 static int handle_modify_delete(struct merge_options *o,
1708 const char *path,
1709 struct object_id *o_oid, int o_mode,
1710 struct object_id *a_oid, int a_mode,
1711 struct object_id *b_oid, int b_mode)
1712 {
1713 const char *modify_branch, *delete_branch;
1714 struct object_id *changed_oid;
1715 int changed_mode;
1716
1717 if (a_oid) {
1718 modify_branch = o->branch1;
1719 delete_branch = o->branch2;
1720 changed_oid = a_oid;
1721 changed_mode = a_mode;
1722 } else {
1723 modify_branch = o->branch2;
1724 delete_branch = o->branch1;
1725 changed_oid = b_oid;
1726 changed_mode = b_mode;
1727 }
1728
1729 return handle_change_delete(o,
1730 path, NULL,
1731 o_oid, o_mode,
1732 changed_oid, changed_mode,
1733 modify_branch, delete_branch,
1734 _("modify"), _("modified"));
1735 }
1736
1737 static int merge_content(struct merge_options *o,
1738 const char *path,
1739 struct object_id *o_oid, int o_mode,
1740 struct object_id *a_oid, int a_mode,
1741 struct object_id *b_oid, int b_mode,
1742 struct rename_conflict_info *rename_conflict_info)
1743 {
1744 const char *reason = _("content");
1745 const char *path1 = NULL, *path2 = NULL;
1746 struct merge_file_info mfi;
1747 struct diff_filespec one, a, b;
1748 unsigned df_conflict_remains = 0;
1749
1750 if (!o_oid) {
1751 reason = _("add/add");
1752 o_oid = (struct object_id *)&null_oid;
1753 }
1754 one.path = a.path = b.path = (char *)path;
1755 oidcpy(&one.oid, o_oid);
1756 one.mode = o_mode;
1757 oidcpy(&a.oid, a_oid);
1758 a.mode = a_mode;
1759 oidcpy(&b.oid, b_oid);
1760 b.mode = b_mode;
1761
1762 if (rename_conflict_info) {
1763 struct diff_filepair *pair1 = rename_conflict_info->pair1;
1764
1765 path1 = (o->branch1 == rename_conflict_info->branch1) ?
1766 pair1->two->path : pair1->one->path;
1767 /* If rename_conflict_info->pair2 != NULL, we are in
1768 * RENAME_ONE_FILE_TO_ONE case. Otherwise, we have a
1769 * normal rename.
1770 */
1771 path2 = (rename_conflict_info->pair2 ||
1772 o->branch2 == rename_conflict_info->branch1) ?
1773 pair1->two->path : pair1->one->path;
1774
1775 if (dir_in_way(path, !o->call_depth,
1776 S_ISGITLINK(pair1->two->mode)))
1777 df_conflict_remains = 1;
1778 }
1779 if (merge_file_special_markers(o, &one, &a, &b,
1780 o->branch1, path1,
1781 o->branch2, path2, &mfi))
1782 return -1;
1783
1784 if (mfi.clean && !df_conflict_remains &&
1785 oid_eq(&mfi.oid, a_oid) && mfi.mode == a_mode) {
1786 int path_renamed_outside_HEAD;
1787 output(o, 3, _("Skipped %s (merged same as existing)"), path);
1788 /*
1789 * The content merge resulted in the same file contents we
1790 * already had. We can return early if those file contents
1791 * are recorded at the correct path (which may not be true
1792 * if the merge involves a rename).
1793 */
1794 path_renamed_outside_HEAD = !path2 || !strcmp(path, path2);
1795 if (!path_renamed_outside_HEAD) {
1796 add_cacheinfo(o, mfi.mode, &mfi.oid, path,
1797 0, (!o->call_depth), 0);
1798 return mfi.clean;
1799 }
1800 } else
1801 output(o, 2, _("Auto-merging %s"), path);
1802
1803 if (!mfi.clean) {
1804 if (S_ISGITLINK(mfi.mode))
1805 reason = _("submodule");
1806 output(o, 1, _("CONFLICT (%s): Merge conflict in %s"),
1807 reason, path);
1808 if (rename_conflict_info && !df_conflict_remains)
1809 if (update_stages(o, path, &one, &a, &b))
1810 return -1;
1811 }
1812
1813 if (df_conflict_remains) {
1814 char *new_path;
1815 if (o->call_depth) {
1816 remove_file_from_cache(path);
1817 } else {
1818 if (!mfi.clean) {
1819 if (update_stages(o, path, &one, &a, &b))
1820 return -1;
1821 } else {
1822 int file_from_stage2 = was_tracked(path);
1823 struct diff_filespec merged;
1824 oidcpy(&merged.oid, &mfi.oid);
1825 merged.mode = mfi.mode;
1826
1827 if (update_stages(o, path, NULL,
1828 file_from_stage2 ? &merged : NULL,
1829 file_from_stage2 ? NULL : &merged))
1830 return -1;
1831 }
1832
1833 }
1834 new_path = unique_path(o, path, rename_conflict_info->branch1);
1835 output(o, 1, _("Adding as %s instead"), new_path);
1836 if (update_file(o, 0, &mfi.oid, mfi.mode, new_path)) {
1837 free(new_path);
1838 return -1;
1839 }
1840 free(new_path);
1841 mfi.clean = 0;
1842 } else if (update_file(o, mfi.clean, &mfi.oid, mfi.mode, path))
1843 return -1;
1844 return mfi.clean;
1845 }
1846
1847 /* Per entry merge function */
1848 static int process_entry(struct merge_options *o,
1849 const char *path, struct stage_data *entry)
1850 {
1851 int clean_merge = 1;
1852 int normalize = o->renormalize;
1853 unsigned o_mode = entry->stages[1].mode;
1854 unsigned a_mode = entry->stages[2].mode;
1855 unsigned b_mode = entry->stages[3].mode;
1856 struct object_id *o_oid = stage_oid(&entry->stages[1].oid, o_mode);
1857 struct object_id *a_oid = stage_oid(&entry->stages[2].oid, a_mode);
1858 struct object_id *b_oid = stage_oid(&entry->stages[3].oid, b_mode);
1859
1860 entry->processed = 1;
1861 if (entry->rename_conflict_info) {
1862 struct rename_conflict_info *conflict_info = entry->rename_conflict_info;
1863 switch (conflict_info->rename_type) {
1864 case RENAME_NORMAL:
1865 case RENAME_ONE_FILE_TO_ONE:
1866 clean_merge = merge_content(o, path,
1867 o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,
1868 conflict_info);
1869 break;
1870 case RENAME_DELETE:
1871 clean_merge = 0;
1872 if (conflict_rename_delete(o,
1873 conflict_info->pair1,
1874 conflict_info->branch1,
1875 conflict_info->branch2))
1876 clean_merge = -1;
1877 break;
1878 case RENAME_ONE_FILE_TO_TWO:
1879 clean_merge = 0;
1880 if (conflict_rename_rename_1to2(o, conflict_info))
1881 clean_merge = -1;
1882 break;
1883 case RENAME_TWO_FILES_TO_ONE:
1884 clean_merge = 0;
1885 if (conflict_rename_rename_2to1(o, conflict_info))
1886 clean_merge = -1;
1887 break;
1888 default:
1889 entry->processed = 0;
1890 break;
1891 }
1892 } else if (o_oid && (!a_oid || !b_oid)) {
1893 /* Case A: Deleted in one */
1894 if ((!a_oid && !b_oid) ||
1895 (!b_oid && blob_unchanged(o, o_oid, o_mode, a_oid, a_mode, normalize, path)) ||
1896 (!a_oid && blob_unchanged(o, o_oid, o_mode, b_oid, b_mode, normalize, path))) {
1897 /* Deleted in both or deleted in one and
1898 * unchanged in the other */
1899 if (a_oid)
1900 output(o, 2, _("Removing %s"), path);
1901 /* do not touch working file if it did not exist */
1902 remove_file(o, 1, path, !a_oid);
1903 } else {
1904 /* Modify/delete; deleted side may have put a directory in the way */
1905 clean_merge = 0;
1906 if (handle_modify_delete(o, path, o_oid, o_mode,
1907 a_oid, a_mode, b_oid, b_mode))
1908 clean_merge = -1;
1909 }
1910 } else if ((!o_oid && a_oid && !b_oid) ||
1911 (!o_oid && !a_oid && b_oid)) {
1912 /* Case B: Added in one. */
1913 /* [nothing|directory] -> ([nothing|directory], file) */
1914
1915 const char *add_branch;
1916 const char *other_branch;
1917 unsigned mode;
1918 const struct object_id *oid;
1919 const char *conf;
1920
1921 if (a_oid) {
1922 add_branch = o->branch1;
1923 other_branch = o->branch2;
1924 mode = a_mode;
1925 oid = a_oid;
1926 conf = _("file/directory");
1927 } else {
1928 add_branch = o->branch2;
1929 other_branch = o->branch1;
1930 mode = b_mode;
1931 oid = b_oid;
1932 conf = _("directory/file");
1933 }
1934 if (dir_in_way(path,
1935 !o->call_depth && !S_ISGITLINK(a_mode),
1936 0)) {
1937 char *new_path = unique_path(o, path, add_branch);
1938 clean_merge = 0;
1939 output(o, 1, _("CONFLICT (%s): There is a directory with name %s in %s. "
1940 "Adding %s as %s"),
1941 conf, path, other_branch, path, new_path);
1942 if (update_file(o, 0, oid, mode, new_path))
1943 clean_merge = -1;
1944 else if (o->call_depth)
1945 remove_file_from_cache(path);
1946 free(new_path);
1947 } else {
1948 output(o, 2, _("Adding %s"), path);
1949 /* do not overwrite file if already present */
1950 if (update_file_flags(o, oid, mode, path, 1, !a_oid))
1951 clean_merge = -1;
1952 }
1953 } else if (a_oid && b_oid) {
1954 /* Case C: Added in both (check for same permissions) and */
1955 /* case D: Modified in both, but differently. */
1956 clean_merge = merge_content(o, path,
1957 o_oid, o_mode, a_oid, a_mode, b_oid, b_mode,
1958 NULL);
1959 } else if (!o_oid && !a_oid && !b_oid) {
1960 /*
1961 * this entry was deleted altogether. a_mode == 0 means
1962 * we had that path and want to actively remove it.
1963 */
1964 remove_file(o, 1, path, !a_mode);
1965 } else
1966 die("BUG: fatal merge failure, shouldn't happen.");
1967
1968 return clean_merge;
1969 }
1970
1971 int merge_trees(struct merge_options *o,
1972 struct tree *head,
1973 struct tree *merge,
1974 struct tree *common,
1975 struct tree **result)
1976 {
1977 int code, clean;
1978
1979 if (o->subtree_shift) {
1980 merge = shift_tree_object(head, merge, o->subtree_shift);
1981 common = shift_tree_object(head, common, o->subtree_shift);
1982 }
1983
1984 if (oid_eq(&common->object.oid, &merge->object.oid)) {
1985 struct strbuf sb = STRBUF_INIT;
1986
1987 if (!o->call_depth && index_has_changes(&sb)) {
1988 err(o, _("Dirty index: cannot merge (dirty: %s)"),
1989 sb.buf);
1990 return 0;
1991 }
1992 output(o, 0, _("Already up to date!"));
1993 *result = head;
1994 return 1;
1995 }
1996
1997 code = git_merge_trees(o->call_depth, common, head, merge);
1998
1999 if (code != 0) {
2000 if (show(o, 4) || o->call_depth)
2001 err(o, _("merging of trees %s and %s failed"),
2002 oid_to_hex(&head->object.oid),
2003 oid_to_hex(&merge->object.oid));
2004 return -1;
2005 }
2006
2007 if (unmerged_cache()) {
2008 struct string_list *entries, *re_head, *re_merge;
2009 int i;
2010 /*
2011 * Only need the hashmap while processing entries, so
2012 * initialize it here and free it when we are done running
2013 * through the entries. Keeping it in the merge_options as
2014 * opposed to decaring a local hashmap is for convenience
2015 * so that we don't have to pass it to around.
2016 */
2017 hashmap_init(&o->current_file_dir_set, path_hashmap_cmp, NULL, 512);
2018 get_files_dirs(o, head);
2019 get_files_dirs(o, merge);
2020
2021 entries = get_unmerged();
2022 re_head = get_renames(o, head, common, head, merge, entries);
2023 re_merge = get_renames(o, merge, common, head, merge, entries);
2024 clean = process_renames(o, re_head, re_merge);
2025 record_df_conflict_files(o, entries);
2026 if (clean < 0)
2027 goto cleanup;
2028 for (i = entries->nr-1; 0 <= i; i--) {
2029 const char *path = entries->items[i].string;
2030 struct stage_data *e = entries->items[i].util;
2031 if (!e->processed) {
2032 int ret = process_entry(o, path, e);
2033 if (!ret)
2034 clean = 0;
2035 else if (ret < 0) {
2036 clean = ret;
2037 goto cleanup;
2038 }
2039 }
2040 }
2041 for (i = 0; i < entries->nr; i++) {
2042 struct stage_data *e = entries->items[i].util;
2043 if (!e->processed)
2044 die("BUG: unprocessed path??? %s",
2045 entries->items[i].string);
2046 }
2047
2048 cleanup:
2049 string_list_clear(re_merge, 0);
2050 string_list_clear(re_head, 0);
2051 string_list_clear(entries, 1);
2052
2053 hashmap_free(&o->current_file_dir_set, 1);
2054
2055 free(re_merge);
2056 free(re_head);
2057 free(entries);
2058
2059 if (clean < 0)
2060 return clean;
2061 }
2062 else
2063 clean = 1;
2064
2065 if (o->call_depth && !(*result = write_tree_from_memory(o)))
2066 return -1;
2067
2068 return clean;
2069 }
2070
2071 static struct commit_list *reverse_commit_list(struct commit_list *list)
2072 {
2073 struct commit_list *next = NULL, *current, *backup;
2074 for (current = list; current; current = backup) {
2075 backup = current->next;
2076 current->next = next;
2077 next = current;
2078 }
2079 return next;
2080 }
2081
2082 /*
2083 * Merge the commits h1 and h2, return the resulting virtual
2084 * commit object and a flag indicating the cleanness of the merge.
2085 */
2086 int merge_recursive(struct merge_options *o,
2087 struct commit *h1,
2088 struct commit *h2,
2089 struct commit_list *ca,
2090 struct commit **result)
2091 {
2092 struct commit_list *iter;
2093 struct commit *merged_common_ancestors;
2094 struct tree *mrtree;
2095 int clean;
2096
2097 if (show(o, 4)) {
2098 output(o, 4, _("Merging:"));
2099 output_commit_title(o, h1);
2100 output_commit_title(o, h2);
2101 }
2102
2103 if (!ca) {
2104 ca = get_merge_bases(h1, h2);
2105 ca = reverse_commit_list(ca);
2106 }
2107
2108 if (show(o, 5)) {
2109 unsigned cnt = commit_list_count(ca);
2110
2111 output(o, 5, Q_("found %u common ancestor:",
2112 "found %u common ancestors:", cnt), cnt);
2113 for (iter = ca; iter; iter = iter->next)
2114 output_commit_title(o, iter->item);
2115 }
2116
2117 merged_common_ancestors = pop_commit(&ca);
2118 if (merged_common_ancestors == NULL) {
2119 /* if there is no common ancestor, use an empty tree */
2120 struct tree *tree;
2121
2122 tree = lookup_tree(the_hash_algo->empty_tree);
2123 merged_common_ancestors = make_virtual_commit(tree, "ancestor");
2124 }
2125
2126 for (iter = ca; iter; iter = iter->next) {
2127 const char *saved_b1, *saved_b2;
2128 o->call_depth++;
2129 /*
2130 * When the merge fails, the result contains files
2131 * with conflict markers. The cleanness flag is
2132 * ignored (unless indicating an error), it was never
2133 * actually used, as result of merge_trees has always
2134 * overwritten it: the committed "conflicts" were
2135 * already resolved.
2136 */
2137 discard_cache();
2138 saved_b1 = o->branch1;
2139 saved_b2 = o->branch2;
2140 o->branch1 = "Temporary merge branch 1";
2141 o->branch2 = "Temporary merge branch 2";
2142 if (merge_recursive(o, merged_common_ancestors, iter->item,
2143 NULL, &merged_common_ancestors) < 0)
2144 return -1;
2145 o->branch1 = saved_b1;
2146 o->branch2 = saved_b2;
2147 o->call_depth--;
2148
2149 if (!merged_common_ancestors)
2150 return err(o, _("merge returned no commit"));
2151 }
2152
2153 discard_cache();
2154 if (!o->call_depth)
2155 read_cache();
2156
2157 o->ancestor = "merged common ancestors";
2158 clean = merge_trees(o, h1->tree, h2->tree, merged_common_ancestors->tree,
2159 &mrtree);
2160 if (clean < 0) {
2161 flush_output(o);
2162 return clean;
2163 }
2164
2165 if (o->call_depth) {
2166 *result = make_virtual_commit(mrtree, "merged tree");
2167 commit_list_insert(h1, &(*result)->parents);
2168 commit_list_insert(h2, &(*result)->parents->next);
2169 }
2170 flush_output(o);
2171 if (!o->call_depth && o->buffer_output < 2)
2172 strbuf_release(&o->obuf);
2173 if (show(o, 2))
2174 diff_warn_rename_limit("merge.renamelimit",
2175 o->needed_rename_limit, 0);
2176 return clean;
2177 }
2178
2179 static struct commit *get_ref(const struct object_id *oid, const char *name)
2180 {
2181 struct object *object;
2182
2183 object = deref_tag(parse_object(oid), name, strlen(name));
2184 if (!object)
2185 return NULL;
2186 if (object->type == OBJ_TREE)
2187 return make_virtual_commit((struct tree*)object, name);
2188 if (object->type != OBJ_COMMIT)
2189 return NULL;
2190 if (parse_commit((struct commit *)object))
2191 return NULL;
2192 return (struct commit *)object;
2193 }
2194
2195 int merge_recursive_generic(struct merge_options *o,
2196 const struct object_id *head,
2197 const struct object_id *merge,
2198 int num_base_list,
2199 const struct object_id **base_list,
2200 struct commit **result)
2201 {
2202 int clean;
2203 struct lock_file lock = LOCK_INIT;
2204 struct commit *head_commit = get_ref(head, o->branch1);
2205 struct commit *next_commit = get_ref(merge, o->branch2);
2206 struct commit_list *ca = NULL;
2207
2208 if (base_list) {
2209 int i;
2210 for (i = 0; i < num_base_list; ++i) {
2211 struct commit *base;
2212 if (!(base = get_ref(base_list[i], oid_to_hex(base_list[i]))))
2213 return err(o, _("Could not parse object '%s'"),
2214 oid_to_hex(base_list[i]));
2215 commit_list_insert(base, &ca);
2216 }
2217 }
2218
2219 hold_locked_index(&lock, LOCK_DIE_ON_ERROR);
2220 clean = merge_recursive(o, head_commit, next_commit, ca,
2221 result);
2222 if (clean < 0) {
2223 rollback_lock_file(&lock);
2224 return clean;
2225 }
2226
2227 if (write_locked_index(&the_index, &lock,
2228 COMMIT_LOCK | SKIP_IF_UNCHANGED))
2229 return err(o, _("Unable to write index."));
2230
2231 return clean ? 0 : 1;
2232 }
2233
2234 static void merge_recursive_config(struct merge_options *o)
2235 {
2236 git_config_get_int("merge.verbosity", &o->verbosity);
2237 git_config_get_int("diff.renamelimit", &o->diff_rename_limit);
2238 git_config_get_int("merge.renamelimit", &o->merge_rename_limit);
2239 git_config(git_xmerge_config, NULL);
2240 }
2241
2242 void init_merge_options(struct merge_options *o)
2243 {
2244 const char *merge_verbosity;
2245 memset(o, 0, sizeof(struct merge_options));
2246 o->verbosity = 2;
2247 o->buffer_output = 1;
2248 o->diff_rename_limit = -1;
2249 o->merge_rename_limit = -1;
2250 o->renormalize = 0;
2251 o->detect_rename = 1;
2252 merge_recursive_config(o);
2253 merge_verbosity = getenv("GIT_MERGE_VERBOSITY");
2254 if (merge_verbosity)
2255 o->verbosity = strtol(merge_verbosity, NULL, 10);
2256 if (o->verbosity >= 5)
2257 o->buffer_output = 0;
2258 strbuf_init(&o->obuf, 0);
2259 string_list_init(&o->df_conflict_file_set, 1);
2260 }
2261
2262 int parse_merge_opt(struct merge_options *o, const char *s)
2263 {
2264 const char *arg;
2265
2266 if (!s || !*s)
2267 return -1;
2268 if (!strcmp(s, "ours"))
2269 o->recursive_variant = MERGE_RECURSIVE_OURS;
2270 else if (!strcmp(s, "theirs"))
2271 o->recursive_variant = MERGE_RECURSIVE_THEIRS;
2272 else if (!strcmp(s, "subtree"))
2273 o->subtree_shift = "";
2274 else if (skip_prefix(s, "subtree=", &arg))
2275 o->subtree_shift = arg;
2276 else if (!strcmp(s, "patience"))
2277 o->xdl_opts = DIFF_WITH_ALG(o, PATIENCE_DIFF);
2278 else if (!strcmp(s, "histogram"))
2279 o->xdl_opts = DIFF_WITH_ALG(o, HISTOGRAM_DIFF);
2280 else if (skip_prefix(s, "diff-algorithm=", &arg)) {
2281 long value = parse_algorithm_value(arg);
2282 if (value < 0)
2283 return -1;
2284 /* clear out previous settings */
2285 DIFF_XDL_CLR(o, NEED_MINIMAL);
2286 o->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK;
2287 o->xdl_opts |= value;
2288 }
2289 else if (!strcmp(s, "ignore-space-change"))
2290 DIFF_XDL_SET(o, IGNORE_WHITESPACE_CHANGE);
2291 else if (!strcmp(s, "ignore-all-space"))
2292 DIFF_XDL_SET(o, IGNORE_WHITESPACE);
2293 else if (!strcmp(s, "ignore-space-at-eol"))
2294 DIFF_XDL_SET(o, IGNORE_WHITESPACE_AT_EOL);
2295 else if (!strcmp(s, "ignore-cr-at-eol"))
2296 DIFF_XDL_SET(o, IGNORE_CR_AT_EOL);
2297 else if (!strcmp(s, "renormalize"))
2298 o->renormalize = 1;
2299 else if (!strcmp(s, "no-renormalize"))
2300 o->renormalize = 0;
2301 else if (!strcmp(s, "no-renames"))
2302 o->detect_rename = 0;
2303 else if (!strcmp(s, "find-renames")) {
2304 o->detect_rename = 1;
2305 o->rename_score = 0;
2306 }
2307 else if (skip_prefix(s, "find-renames=", &arg) ||
2308 skip_prefix(s, "rename-threshold=", &arg)) {
2309 if ((o->rename_score = parse_rename_score(&arg)) == -1 || *arg != 0)
2310 return -1;
2311 o->detect_rename = 1;
2312 }
2313 else
2314 return -1;
2315 return 0;
2316 }