1 #define USE_THE_INDEX_VARIABLE
4 #include "xdiff-interface.h"
9 #include "commit-reach.h"
10 #include "merge-ort.h"
11 #include "object-name.h"
12 #include "object-store-ll.h"
13 #include "parse-options.h"
14 #include "repository.h"
17 #include "merge-blobs.h"
22 static int line_termination
= '\n';
25 struct merge_list
*next
;
26 struct merge_list
*link
; /* other stages for this object */
28 unsigned int stage
: 2;
34 static struct merge_list
*merge_result
, **merge_result_end
= &merge_result
;
36 static void add_merge_entry(struct merge_list
*entry
)
38 *merge_result_end
= entry
;
39 merge_result_end
= &entry
->next
;
42 static void trivial_merge_trees(struct tree_desc t
[3], const char *base
);
44 static const char *explanation(struct merge_list
*entry
)
46 switch (entry
->stage
) {
50 return "added in remote";
53 return "added in both";
54 return "added in local";
60 return "removed in both";
63 return "changed in both";
65 if (entry
->stage
== 3)
66 return "removed in local";
67 return "removed in remote";
70 static void *result(struct merge_list
*entry
, unsigned long *size
)
72 enum object_type type
;
73 struct blob
*base
, *our
, *their
;
74 const char *path
= entry
->path
;
77 return repo_read_object_file(the_repository
,
78 &entry
->blob
->object
.oid
, &type
,
81 if (entry
->stage
== 1) {
86 if (entry
&& entry
->stage
== 2) {
93 return merge_blobs(the_repository
->index
, path
,
94 base
, our
, their
, size
);
97 static void *origin(struct merge_list
*entry
, unsigned long *size
)
99 enum object_type type
;
101 if (entry
->stage
== 2)
102 return repo_read_object_file(the_repository
,
103 &entry
->blob
->object
.oid
,
110 static int show_outf(void *priv UNUSED
, mmbuffer_t
*mb
, int nbuf
)
113 for (i
= 0; i
< nbuf
; i
++)
114 printf("%.*s", (int) mb
[i
].size
, mb
[i
].ptr
);
118 static void show_diff(struct merge_list
*entry
)
124 xdemitcb_t ecb
= { .out_line
= show_outf
};
126 memset(&xpp
, 0, sizeof(xpp
));
128 memset(&xecfg
, 0, sizeof(xecfg
));
131 src
.ptr
= origin(entry
, &size
);
135 dst
.ptr
= result(entry
, &size
);
139 if (xdi_diff(&src
, &dst
, &xpp
, &xecfg
, &ecb
))
140 die("unable to generate diff");
145 static void show_result_list(struct merge_list
*entry
)
147 printf("%s\n", explanation(entry
));
149 struct merge_list
*link
= entry
->link
;
150 static const char *desc
[4] = { "result", "base", "our", "their" };
151 printf(" %-6s %o %s %s\n", desc
[entry
->stage
], entry
->mode
, oid_to_hex(&entry
->blob
->object
.oid
), entry
->path
);
156 static void show_result(void)
158 struct merge_list
*walk
;
162 show_result_list(walk
);
168 /* An empty entry never compares same, not even to another empty entry */
169 static int same_entry(struct name_entry
*a
, struct name_entry
*b
)
171 return !is_null_oid(&a
->oid
) &&
172 !is_null_oid(&b
->oid
) &&
173 oideq(&a
->oid
, &b
->oid
) &&
177 static int both_empty(struct name_entry
*a
, struct name_entry
*b
)
179 return is_null_oid(&a
->oid
) && is_null_oid(&b
->oid
);
182 static struct merge_list
*create_entry(unsigned stage
, unsigned mode
, const struct object_id
*oid
, const char *path
)
184 struct merge_list
*res
= xcalloc(1, sizeof(*res
));
189 res
->blob
= lookup_blob(the_repository
, oid
);
193 static char *traverse_path(const struct traverse_info
*info
, const struct name_entry
*n
)
195 struct strbuf buf
= STRBUF_INIT
;
196 strbuf_make_traverse_path(&buf
, info
, n
->path
, n
->pathlen
);
197 return strbuf_detach(&buf
, NULL
);
200 static void resolve(const struct traverse_info
*info
, struct name_entry
*ours
, struct name_entry
*result
)
202 struct merge_list
*orig
, *final
;
205 /* If it's already ours, don't bother showing it */
209 path
= traverse_path(info
, result
);
210 orig
= create_entry(2, ours
->mode
, &ours
->oid
, path
);
211 final
= create_entry(0, result
->mode
, &result
->oid
, path
);
215 add_merge_entry(final
);
218 static void unresolved_directory(const struct traverse_info
*info
,
219 struct name_entry n
[3])
221 struct repository
*r
= the_repository
;
223 struct name_entry
*p
;
224 struct tree_desc t
[3];
225 void *buf0
, *buf1
, *buf2
;
227 for (p
= n
; p
< n
+ 3; p
++) {
228 if (p
->mode
&& S_ISDIR(p
->mode
))
232 return; /* there is no tree here */
234 newbase
= traverse_path(info
, p
);
236 #define ENTRY_OID(e) (((e)->mode && S_ISDIR((e)->mode)) ? &(e)->oid : NULL)
237 buf0
= fill_tree_descriptor(r
, t
+ 0, ENTRY_OID(n
+ 0));
238 buf1
= fill_tree_descriptor(r
, t
+ 1, ENTRY_OID(n
+ 1));
239 buf2
= fill_tree_descriptor(r
, t
+ 2, ENTRY_OID(n
+ 2));
242 trivial_merge_trees(t
, newbase
);
251 static struct merge_list
*link_entry(unsigned stage
, const struct traverse_info
*info
, struct name_entry
*n
, struct merge_list
*entry
)
254 struct merge_list
*link
;
261 path
= traverse_path(info
, n
);
262 link
= create_entry(stage
, n
->mode
, &n
->oid
, path
);
267 static void unresolved(const struct traverse_info
*info
, struct name_entry n
[3])
269 struct merge_list
*entry
= NULL
;
271 unsigned dirmask
= 0, mask
= 0;
273 for (i
= 0; i
< 3; i
++) {
276 * Treat missing entries as directories so that we return
277 * after unresolved_directory has handled this.
279 if (!n
[i
].mode
|| S_ISDIR(n
[i
].mode
))
283 unresolved_directory(info
, n
);
288 if (n
[2].mode
&& !S_ISDIR(n
[2].mode
))
289 entry
= link_entry(3, info
, n
+ 2, entry
);
290 if (n
[1].mode
&& !S_ISDIR(n
[1].mode
))
291 entry
= link_entry(2, info
, n
+ 1, entry
);
292 if (n
[0].mode
&& !S_ISDIR(n
[0].mode
))
293 entry
= link_entry(1, info
, n
+ 0, entry
);
295 add_merge_entry(entry
);
299 * Merge two trees together (t[1] and t[2]), using a common base (t[0])
302 * This walks the (sorted) trees in lock-step, checking every possible
303 * name. Note that directories automatically sort differently from other
304 * files (see "base_name_compare"), so you'll never see file/directory
305 * conflicts, because they won't ever compare the same.
307 * IOW, if a directory changes to a filename, it will automatically be
308 * seen as the directory going away, and the filename being created.
310 * Think of this as a three-way diff.
312 * The output will be either:
314 * "0 mode sha1 filename"
315 * NOTE NOTE NOTE! FIXME! We really really need to walk the index
316 * in parallel with this too!
319 * "1 mode sha1 filename"
320 * "2 mode sha1 filename"
321 * "3 mode sha1 filename"
322 * where not all of the 1/2/3 lines may exist, of course.
324 * The successful merge rules are the same as for the three-way merge
327 static int threeway_callback(int n
, unsigned long mask
, unsigned long dirmask
, struct name_entry
*entry
, struct traverse_info
*info
)
330 if (same_entry(entry
+1, entry
+2) || both_empty(entry
+1, entry
+2)) {
331 /* Modified, added or removed identically */
332 resolve(info
, NULL
, entry
+1);
336 if (same_entry(entry
+0, entry
+1)) {
337 if (!is_null_oid(&entry
[2].oid
) && !S_ISDIR(entry
[2].mode
)) {
338 /* We did not touch, they modified -- take theirs */
339 resolve(info
, entry
+1, entry
+2);
343 * If we did not touch a directory but they made it
344 * into a file, we fall through and unresolved()
345 * recurses down. Likewise for the opposite case.
349 if (same_entry(entry
+0, entry
+2) || both_empty(entry
+0, entry
+2)) {
350 /* We added, modified or removed, they did not touch -- take ours */
351 resolve(info
, NULL
, entry
+1);
355 unresolved(info
, entry
);
359 static void trivial_merge_trees(struct tree_desc t
[3], const char *base
)
361 struct traverse_info info
;
363 setup_traverse_info(&info
, base
);
364 info
.fn
= threeway_callback
;
365 traverse_trees(&the_index
, 3, t
, &info
);
368 static void *get_tree_descriptor(struct repository
*r
,
369 struct tree_desc
*desc
,
372 struct object_id oid
;
375 if (repo_get_oid(r
, rev
, &oid
))
376 die("unknown rev %s", rev
);
377 buf
= fill_tree_descriptor(r
, desc
, &oid
);
379 die("%s is not a tree", rev
);
383 static int trivial_merge(const char *base
,
387 struct repository
*r
= the_repository
;
388 struct tree_desc t
[3];
389 void *buf1
, *buf2
, *buf3
;
391 buf1
= get_tree_descriptor(r
, t
+0, base
);
392 buf2
= get_tree_descriptor(r
, t
+1, branch1
);
393 buf3
= get_tree_descriptor(r
, t
+2, branch2
);
394 trivial_merge_trees(t
, "");
409 struct merge_tree_options
{
411 int allow_unrelated_histories
;
417 static int real_merge(struct merge_tree_options
*o
,
418 const char *merge_base
,
419 const char *branch1
, const char *branch2
,
422 struct commit
*parent1
, *parent2
;
423 struct commit_list
*merge_bases
= NULL
;
424 struct merge_options opt
;
425 struct merge_result result
= { 0 };
426 int show_messages
= o
->show_messages
;
428 parent1
= get_merge_parent(branch1
);
430 help_unknown_ref(branch1
, "merge-tree",
431 _("not something we can merge"));
433 parent2
= get_merge_parent(branch2
);
435 help_unknown_ref(branch2
, "merge-tree",
436 _("not something we can merge"));
438 init_merge_options(&opt
, the_repository
);
440 opt
.show_rename_progress
= 0;
442 opt
.branch1
= branch1
;
443 opt
.branch2
= branch2
;
446 struct commit
*base_commit
;
447 struct tree
*base_tree
, *parent1_tree
, *parent2_tree
;
449 base_commit
= lookup_commit_reference_by_name(merge_base
);
451 die(_("could not lookup commit '%s'"), merge_base
);
453 opt
.ancestor
= merge_base
;
454 base_tree
= repo_get_commit_tree(the_repository
, base_commit
);
455 parent1_tree
= repo_get_commit_tree(the_repository
, parent1
);
456 parent2_tree
= repo_get_commit_tree(the_repository
, parent2
);
457 merge_incore_nonrecursive(&opt
, base_tree
, parent1_tree
, parent2_tree
, &result
);
460 * Get the merge bases, in reverse order; see comment above
461 * merge_incore_recursive in merge-ort.h
463 merge_bases
= repo_get_merge_bases(the_repository
, parent1
,
465 if (!merge_bases
&& !o
->allow_unrelated_histories
)
466 die(_("refusing to merge unrelated histories"));
467 merge_bases
= reverse_commit_list(merge_bases
);
468 merge_incore_recursive(&opt
, merge_bases
, parent1
, parent2
, &result
);
471 if (result
.clean
< 0)
472 die(_("failure to merge"));
474 if (show_messages
== -1)
475 show_messages
= !result
.clean
;
478 printf("%d%c", result
.clean
, line_termination
);
479 printf("%s%c", oid_to_hex(&result
.tree
->object
.oid
), line_termination
);
481 struct string_list conflicted_files
= STRING_LIST_INIT_NODUP
;
482 const char *last
= NULL
;
485 merge_get_conflicted_files(&result
, &conflicted_files
);
486 for (i
= 0; i
< conflicted_files
.nr
; i
++) {
487 const char *name
= conflicted_files
.items
[i
].string
;
488 struct stage_info
*c
= conflicted_files
.items
[i
].util
;
490 printf("%06o %s %d\t",
491 c
->mode
, oid_to_hex(&c
->oid
), c
->stage
);
492 else if (last
&& !strcmp(last
, name
))
494 write_name_quoted_relative(
495 name
, prefix
, stdout
, line_termination
);
498 string_list_clear(&conflicted_files
, 1);
501 putchar(line_termination
);
502 merge_display_update_messages(&opt
, line_termination
== '\0',
506 putchar(line_termination
);
507 merge_finalize(&opt
, &result
);
508 return !result
.clean
; /* result.clean < 0 handled above */
511 int cmd_merge_tree(int argc
, const char **argv
, const char *prefix
)
513 struct merge_tree_options o
= { .show_messages
= -1 };
514 int expected_remaining_argc
;
516 const char *merge_base
= NULL
;
518 const char * const merge_tree_usage
[] = {
519 N_("git merge-tree [--write-tree] [<options>] <branch1> <branch2>"),
520 N_("git merge-tree [--trivial-merge] <base-tree> <branch1> <branch2>"),
523 struct option mt_options
[] = {
524 OPT_CMDMODE(0, "write-tree", &o
.mode
,
525 N_("do a real merge instead of a trivial merge"),
527 OPT_CMDMODE(0, "trivial-merge", &o
.mode
,
528 N_("do a trivial merge only"), MODE_TRIVIAL
),
529 OPT_BOOL(0, "messages", &o
.show_messages
,
530 N_("also show informational/conflict messages")),
531 OPT_SET_INT('z', NULL
, &line_termination
,
532 N_("separate paths with the NUL character"), '\0'),
533 OPT_BOOL_F(0, "name-only",
535 N_("list filenames without modes/oids/stages"),
537 OPT_BOOL_F(0, "allow-unrelated-histories",
538 &o
.allow_unrelated_histories
,
539 N_("allow merging unrelated histories"),
541 OPT_BOOL_F(0, "stdin",
543 N_("perform multiple merges, one per line of input"),
545 OPT_STRING(0, "merge-base",
548 N_("specify a merge-base for the merge")),
552 /* Parse arguments */
553 original_argc
= argc
- 1; /* ignoring argv[0] */
554 argc
= parse_options(argc
, argv
, prefix
, mt_options
,
555 merge_tree_usage
, PARSE_OPT_STOP_AT_NON_OPTION
);
559 struct strbuf buf
= STRBUF_INIT
;
561 if (o
.mode
== MODE_TRIVIAL
)
562 die(_("--trivial-merge is incompatible with all other options"));
564 die(_("--merge-base is incompatible with --stdin"));
565 line_termination
= '\0';
566 while (strbuf_getline_lf(&buf
, stdin
) != EOF
) {
567 struct strbuf
**split
;
569 const char *input_merge_base
= NULL
;
571 split
= strbuf_split(&buf
, ' ');
572 if (!split
[0] || !split
[1])
573 die(_("malformed input line: '%s'."), buf
.buf
);
574 strbuf_rtrim(split
[0]);
575 strbuf_rtrim(split
[1]);
577 /* parse the merge-base */
578 if (!strcmp(split
[1]->buf
, "--")) {
579 input_merge_base
= split
[0]->buf
;
582 if (input_merge_base
&& split
[2] && split
[3] && !split
[4]) {
583 strbuf_rtrim(split
[2]);
584 strbuf_rtrim(split
[3]);
585 result
= real_merge(&o
, input_merge_base
, split
[2]->buf
, split
[3]->buf
, prefix
);
586 } else if (!input_merge_base
&& !split
[2]) {
587 result
= real_merge(&o
, NULL
, split
[0]->buf
, split
[1]->buf
, prefix
);
589 die(_("malformed input line: '%s'."), buf
.buf
);
593 die(_("merging cannot continue; got unclean result of %d"), result
);
594 strbuf_list_free(split
);
596 strbuf_release(&buf
);
600 /* Figure out which mode to use */
603 BUG("unexpected command mode %d", o
.mode
);
607 usage_with_options(merge_tree_usage
, mt_options
);
612 o
.mode
= MODE_TRIVIAL
;
615 expected_remaining_argc
= argc
;
618 expected_remaining_argc
= 2;
621 expected_remaining_argc
= 3;
622 /* Removal of `--trivial-merge` is expected */
626 if (o
.mode
== MODE_TRIVIAL
&& argc
< original_argc
)
627 die(_("--trivial-merge is incompatible with all other options"));
629 if (argc
!= expected_remaining_argc
)
630 usage_with_options(merge_tree_usage
, mt_options
);
632 git_config(git_default_config
, NULL
);
634 /* Do the relevant type of merge */
635 if (o
.mode
== MODE_REAL
)
636 return real_merge(&o
, merge_base
, argv
[0], argv
[1], prefix
);
638 return trivial_merge(argv
[0], argv
[1], argv
[2]);