]> git.ipfire.org Git - thirdparty/git.git/blame - builtin/merge-tree.c
Merge branch 'ds/remove-idx-before-pack'
[thirdparty/git.git] / builtin / merge-tree.c
CommitLineData
666f53eb 1#define USE_THE_INDEX_VARIABLE
c2e86add 2#include "builtin.h"
1b0c7174 3#include "tree-walk.h"
0c799383 4#include "xdiff-interface.h"
1f0c3a29 5#include "help.h"
f394e093 6#include "gettext.h"
41771fa4 7#include "hex.h"
66265a69 8#include "commit.h"
1f0c3a29
EN
9#include "commit-reach.h"
10#include "merge-ort.h"
dabab1d6 11#include "object-name.h"
cbd53a21 12#include "object-store.h"
6ec755a0 13#include "parse-options.h"
da14a7ff 14#include "repository.h"
83788070 15#include "blob.h"
d807c4a0 16#include "exec-cmd.h"
fa2364ec 17#include "merge-blobs.h"
7fa33388 18#include "quote.h"
d4a4f929 19#include "tree.h"
b6551fea 20#include "config.h"
7fa33388
EN
21
22static int line_termination = '\n';
492e0759 23
83788070
LT
24struct merge_list {
25 struct merge_list *next;
26 struct merge_list *link; /* other stages for this object */
27
b13112fa 28 unsigned int stage : 2;
83788070
LT
29 unsigned int mode;
30 const char *path;
31 struct blob *blob;
32};
33
34static struct merge_list *merge_result, **merge_result_end = &merge_result;
35
36static void add_merge_entry(struct merge_list *entry)
37{
38 *merge_result_end = entry;
39 merge_result_end = &entry->next;
40}
41
70176b70 42static void trivial_merge_trees(struct tree_desc t[3], const char *base);
492e0759 43
83788070
LT
44static const char *explanation(struct merge_list *entry)
45{
46 switch (entry->stage) {
47 case 0:
48 return "merged";
49 case 3:
50 return "added in remote";
51 case 2:
52 if (entry->link)
53 return "added in both";
54 return "added in local";
55 }
56
57 /* Existed in base */
58 entry = entry->link;
59 if (!entry)
60 return "removed in both";
61
62 if (entry->link)
63 return "changed in both";
64
65 if (entry->stage == 3)
66 return "removed in local";
67 return "removed in remote";
68}
69
0c799383
LT
70static void *result(struct merge_list *entry, unsigned long *size)
71{
21666f1a 72 enum object_type type;
0c799383 73 struct blob *base, *our, *their;
21baa6e0 74 const char *path = entry->path;
0c799383
LT
75
76 if (!entry->stage)
bc726bd0
ÆAB
77 return repo_read_object_file(the_repository,
78 &entry->blob->object.oid, &type,
79 size);
0c799383
LT
80 base = NULL;
81 if (entry->stage == 1) {
82 base = entry->blob;
83 entry = entry->link;
84 }
85 our = NULL;
86 if (entry && entry->stage == 2) {
87 our = entry->blob;
88 entry = entry->link;
89 }
90 their = NULL;
91 if (entry)
92 their = entry->blob;
f8adbec9
NTND
93 return merge_blobs(the_repository->index, path,
94 base, our, their, size);
0c799383
LT
95}
96
97static void *origin(struct merge_list *entry, unsigned long *size)
98{
21666f1a 99 enum object_type type;
0c799383
LT
100 while (entry) {
101 if (entry->stage == 2)
bc726bd0
ÆAB
102 return repo_read_object_file(the_repository,
103 &entry->blob->object.oid,
104 &type, size);
0c799383
LT
105 entry = entry->link;
106 }
107 return NULL;
108}
109
61bdc7c5 110static int show_outf(void *priv UNUSED, mmbuffer_t *mb, int nbuf)
0c799383
LT
111{
112 int i;
113 for (i = 0; i < nbuf; i++)
114 printf("%.*s", (int) mb[i].size, mb[i].ptr);
115 return 0;
116}
117
118static void show_diff(struct merge_list *entry)
119{
120 unsigned long size;
121 mmfile_t src, dst;
122 xpparam_t xpp;
123 xdemitconf_t xecfg;
22233d43 124 xdemitcb_t ecb = { .out_line = show_outf };
0c799383 125
ec7967cf 126 memset(&xpp, 0, sizeof(xpp));
582aa00b 127 xpp.flags = 0;
30b25010 128 memset(&xecfg, 0, sizeof(xecfg));
0c799383 129 xecfg.ctxlen = 3;
0c799383
LT
130
131 src.ptr = origin(entry, &size);
132 if (!src.ptr)
133 size = 0;
134 src.size = size;
135 dst.ptr = result(entry, &size);
136 if (!dst.ptr)
137 size = 0;
138 dst.size = size;
3efb9880
JK
139 if (xdi_diff(&src, &dst, &xpp, &xecfg, &ecb))
140 die("unable to generate diff");
0c799383
LT
141 free(src.ptr);
142 free(dst.ptr);
143}
144
83788070
LT
145static void show_result_list(struct merge_list *entry)
146{
147 printf("%s\n", explanation(entry));
148 do {
149 struct merge_list *link = entry->link;
150 static const char *desc[4] = { "result", "base", "our", "their" };
f2fd0760 151 printf(" %-6s %o %s %s\n", desc[entry->stage], entry->mode, oid_to_hex(&entry->blob->object.oid), entry->path);
83788070
LT
152 entry = link;
153 } while (entry);
154}
155
156static void show_result(void)
157{
158 struct merge_list *walk;
159
160 walk = merge_result;
161 while (walk) {
162 show_result_list(walk);
0c799383 163 show_diff(walk);
83788070
LT
164 walk = walk->next;
165 }
166}
167
492e0759
LT
168/* An empty entry never compares same, not even to another empty entry */
169static int same_entry(struct name_entry *a, struct name_entry *b)
170{
ea82b2a0 171 return !is_null_oid(&a->oid) &&
172 !is_null_oid(&b->oid) &&
173 oideq(&a->oid, &b->oid) &&
492e0759
LT
174 a->mode == b->mode;
175}
176
aacecc3b
JK
177static int both_empty(struct name_entry *a, struct name_entry *b)
178{
ea82b2a0 179 return is_null_oid(&a->oid) && is_null_oid(&b->oid);
aacecc3b
JK
180}
181
3e930981 182static struct merge_list *create_entry(unsigned stage, unsigned mode, const struct object_id *oid, const char *path)
492e0759 183{
19d4b416 184 struct merge_list *res = xcalloc(1, sizeof(*res));
83788070 185
83788070
LT
186 res->stage = stage;
187 res->path = path;
188 res->mode = mode;
da14a7ff 189 res->blob = lookup_blob(the_repository, oid);
83788070 190 return res;
01df5297
LT
191}
192
40d934df
LT
193static char *traverse_path(const struct traverse_info *info, const struct name_entry *n)
194{
c43ab062
JK
195 struct strbuf buf = STRBUF_INIT;
196 strbuf_make_traverse_path(&buf, info, n->path, n->pathlen);
197 return strbuf_detach(&buf, NULL);
40d934df
LT
198}
199
8dd15c6a 200static void resolve(const struct traverse_info *info, struct name_entry *ours, struct name_entry *result)
01df5297 201{
83788070
LT
202 struct merge_list *orig, *final;
203 const char *path;
204
8dd15c6a
JH
205 /* If it's already ours, don't bother showing it */
206 if (!ours)
01df5297 207 return;
01df5297 208
40d934df 209 path = traverse_path(info, result);
ea82b2a0 210 orig = create_entry(2, ours->mode, &ours->oid, path);
211 final = create_entry(0, result->mode, &result->oid, path);
83788070
LT
212
213 final->link = orig;
214
215 add_merge_entry(final);
492e0759
LT
216}
217
57065289
RS
218static void unresolved_directory(const struct traverse_info *info,
219 struct name_entry n[3])
492e0759 220{
5e575807 221 struct repository *r = the_repository;
492e0759
LT
222 char *newbase;
223 struct name_entry *p;
224 struct tree_desc t[3];
225 void *buf0, *buf1, *buf2;
226
35ffe758
JH
227 for (p = n; p < n + 3; p++) {
228 if (p->mode && S_ISDIR(p->mode))
229 break;
492e0759 230 }
35ffe758
JH
231 if (n + 3 <= p)
232 return; /* there is no tree here */
8dd15c6a 233
40d934df 234 newbase = traverse_path(info, p);
35ffe758 235
ea82b2a0 236#define ENTRY_OID(e) (((e)->mode && S_ISDIR((e)->mode)) ? &(e)->oid : NULL)
5e575807
NTND
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));
5c377d3d 240#undef ENTRY_OID
35ffe758 241
70176b70 242 trivial_merge_trees(t, newbase);
492e0759
LT
243
244 free(buf0);
245 free(buf1);
246 free(buf2);
247 free(newbase);
492e0759
LT
248}
249
83788070 250
40d934df 251static struct merge_list *link_entry(unsigned stage, const struct traverse_info *info, struct name_entry *n, struct merge_list *entry)
83788070
LT
252{
253 const char *path;
254 struct merge_list *link;
255
256 if (!n->mode)
257 return entry;
258 if (entry)
259 path = entry->path;
260 else
40d934df 261 path = traverse_path(info, n);
ea82b2a0 262 link = create_entry(stage, n->mode, &n->oid, path);
83788070
LT
263 link->link = entry;
264 return link;
265}
266
40d934df 267static void unresolved(const struct traverse_info *info, struct name_entry n[3])
492e0759 268{
83788070 269 struct merge_list *entry = NULL;
35ffe758
JH
270 int i;
271 unsigned dirmask = 0, mask = 0;
272
273 for (i = 0; i < 3; i++) {
187c00c6 274 mask |= (1 << i);
94883b43
JK
275 /*
276 * Treat missing entries as directories so that we return
277 * after unresolved_directory has handled this.
278 */
279 if (!n[i].mode || S_ISDIR(n[i].mode))
35ffe758
JH
280 dirmask |= (1 << i);
281 }
282
57065289 283 unresolved_directory(info, n);
83788070 284
35ffe758 285 if (dirmask == mask)
492e0759 286 return;
83788070 287
35ffe758
JH
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);
83788070
LT
294
295 add_merge_entry(entry);
492e0759
LT
296}
297
164dcb97
LT
298/*
299 * Merge two trees together (t[1] and t[2]), using a common base (t[0])
300 * as the origin.
301 *
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.
306 *
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.
309 *
310 * Think of this as a three-way diff.
311 *
312 * The output will be either:
313 * - successful merge
314 * "0 mode sha1 filename"
315 * NOTE NOTE NOTE! FIXME! We really really need to walk the index
316 * in parallel with this too!
317 *
318 * - conflict:
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.
323 *
324 * The successful merge rules are the same as for the three-way merge
325 * in git-read-tree.
326 */
91e4f036 327static int threeway_callback(int n, unsigned long mask, unsigned long dirmask, struct name_entry *entry, struct traverse_info *info)
164dcb97
LT
328{
329 /* Same in both? */
ab5f4242 330 if (same_entry(entry+1, entry+2) || both_empty(entry+1, entry+2)) {
aacecc3b
JK
331 /* Modified, added or removed identically */
332 resolve(info, NULL, entry+1);
333 return mask;
164dcb97 334 }
492e0759 335
164dcb97 336 if (same_entry(entry+0, entry+1)) {
ea82b2a0 337 if (!is_null_oid(&entry[2].oid) && !S_ISDIR(entry[2].mode)) {
8dd15c6a 338 /* We did not touch, they modified -- take theirs */
40d934df 339 resolve(info, entry+1, entry+2);
5803c6f8 340 return mask;
492e0759 341 }
8dd15c6a
JH
342 /*
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.
346 */
164dcb97 347 }
492e0759 348
aacecc3b
JK
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);
352 return mask;
492e0759 353 }
164dcb97 354
40d934df 355 unresolved(info, entry);
5803c6f8 356 return mask;
164dcb97
LT
357}
358
70176b70 359static void trivial_merge_trees(struct tree_desc t[3], const char *base)
164dcb97 360{
40d934df
LT
361 struct traverse_info info;
362
363 setup_traverse_info(&info, base);
364 info.fn = threeway_callback;
67022e02 365 traverse_trees(&the_index, 3, t, &info);
492e0759
LT
366}
367
5e575807
NTND
368static void *get_tree_descriptor(struct repository *r,
369 struct tree_desc *desc,
370 const char *rev)
492e0759 371{
d1a35e5c 372 struct object_id oid;
492e0759
LT
373 void *buf;
374
5e575807 375 if (repo_get_oid(r, rev, &oid))
492e0759 376 die("unknown rev %s", rev);
5e575807 377 buf = fill_tree_descriptor(r, desc, &oid);
492e0759
LT
378 if (!buf)
379 die("%s is not a tree", rev);
380 return buf;
381}
382
6ec755a0
EN
383static int trivial_merge(const char *base,
384 const char *branch1,
385 const char *branch2)
492e0759 386{
5e575807 387 struct repository *r = the_repository;
492e0759
LT
388 struct tree_desc t[3];
389 void *buf1, *buf2, *buf3;
390
6ec755a0
EN
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);
70176b70 394 trivial_merge_trees(t, "");
492e0759
LT
395 free(buf1);
396 free(buf2);
397 free(buf3);
83788070
LT
398
399 show_result();
492e0759
LT
400 return 0;
401}
55e48f6b 402
6ec755a0
EN
403enum mode {
404 MODE_UNKNOWN,
405 MODE_TRIVIAL,
406 MODE_REAL,
407};
408
409struct merge_tree_options {
410 int mode;
7976721d 411 int allow_unrelated_histories;
a1a78119 412 int show_messages;
b520bc6c 413 int name_only;
ec1edbcb 414 int use_stdin;
6ec755a0
EN
415};
416
417static int real_merge(struct merge_tree_options *o,
66265a69 418 const char *merge_base,
7fa33388
EN
419 const char *branch1, const char *branch2,
420 const char *prefix)
6ec755a0 421{
1f0c3a29
EN
422 struct commit *parent1, *parent2;
423 struct commit_list *merge_bases = NULL;
424 struct merge_options opt;
425 struct merge_result result = { 0 };
ec1edbcb 426 int show_messages = o->show_messages;
1f0c3a29
EN
427
428 parent1 = get_merge_parent(branch1);
429 if (!parent1)
430 help_unknown_ref(branch1, "merge-tree",
431 _("not something we can merge"));
432
433 parent2 = get_merge_parent(branch2);
434 if (!parent2)
435 help_unknown_ref(branch2, "merge-tree",
436 _("not something we can merge"));
437
438 init_merge_options(&opt, the_repository);
439
440 opt.show_rename_progress = 0;
441
442 opt.branch1 = branch1;
443 opt.branch2 = branch2;
444
66265a69
KZ
445 if (merge_base) {
446 struct commit *base_commit;
447 struct tree *base_tree, *parent1_tree, *parent2_tree;
448
449 base_commit = lookup_commit_reference_by_name(merge_base);
450 if (!base_commit)
e4cf0134 451 die(_("could not lookup commit '%s'"), merge_base);
66265a69
KZ
452
453 opt.ancestor = merge_base;
ecb5091f
ÆAB
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);
66265a69
KZ
457 merge_incore_nonrecursive(&opt, base_tree, parent1_tree, parent2_tree, &result);
458 } else {
459 /*
460 * Get the merge bases, in reverse order; see comment above
461 * merge_incore_recursive in merge-ort.h
462 */
cb338c23
ÆAB
463 merge_bases = repo_get_merge_bases(the_repository, parent1,
464 parent2);
66265a69
KZ
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);
469 }
1f0c3a29 470
1f0c3a29
EN
471 if (result.clean < 0)
472 die(_("failure to merge"));
a1a78119 473
ec1edbcb
EN
474 if (show_messages == -1)
475 show_messages = !result.clean;
a1a78119 476
ec1edbcb
EN
477 if (o->use_stdin)
478 printf("%d%c", result.clean, line_termination);
7c48b278 479 printf("%s%c", oid_to_hex(&result.tree->object.oid), line_termination);
7fa33388
EN
480 if (!result.clean) {
481 struct string_list conflicted_files = STRING_LIST_INIT_NODUP;
482 const char *last = NULL;
483 int i;
484
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;
b520bc6c
EN
488 struct stage_info *c = conflicted_files.items[i].util;
489 if (!o->name_only)
490 printf("%06o %s %d\t",
491 c->mode, oid_to_hex(&c->oid), c->stage);
492 else if (last && !strcmp(last, name))
7fa33388
EN
493 continue;
494 write_name_quoted_relative(
495 name, prefix, stdout, line_termination);
496 last = name;
497 }
498 string_list_clear(&conflicted_files, 1);
499 }
ec1edbcb 500 if (show_messages) {
7fa33388 501 putchar(line_termination);
de905811
EN
502 merge_display_update_messages(&opt, line_termination == '\0',
503 &result);
a1a78119 504 }
ec1edbcb
EN
505 if (o->use_stdin)
506 putchar(line_termination);
1f0c3a29
EN
507 merge_finalize(&opt, &result);
508 return !result.clean; /* result.clean < 0 handled above */
6ec755a0
EN
509}
510
55e48f6b
EN
511int cmd_merge_tree(int argc, const char **argv, const char *prefix)
512{
a1a78119 513 struct merge_tree_options o = { .show_messages = -1 };
6ec755a0 514 int expected_remaining_argc;
a1a78119 515 int original_argc;
66265a69 516 const char *merge_base = NULL;
6ec755a0
EN
517
518 const char * const merge_tree_usage[] = {
a1a78119 519 N_("git merge-tree [--write-tree] [<options>] <branch1> <branch2>"),
6ec755a0
EN
520 N_("git merge-tree [--trivial-merge] <base-tree> <branch1> <branch2>"),
521 NULL
522 };
523 struct option mt_options[] = {
524 OPT_CMDMODE(0, "write-tree", &o.mode,
525 N_("do a real merge instead of a trivial merge"),
526 MODE_REAL),
527 OPT_CMDMODE(0, "trivial-merge", &o.mode,
528 N_("do a trivial merge only"), MODE_TRIVIAL),
a1a78119
EN
529 OPT_BOOL(0, "messages", &o.show_messages,
530 N_("also show informational/conflict messages")),
7c48b278
EN
531 OPT_SET_INT('z', NULL, &line_termination,
532 N_("separate paths with the NUL character"), '\0'),
b520bc6c
EN
533 OPT_BOOL_F(0, "name-only",
534 &o.name_only,
535 N_("list filenames without modes/oids/stages"),
536 PARSE_OPT_NONEG),
7976721d
EN
537 OPT_BOOL_F(0, "allow-unrelated-histories",
538 &o.allow_unrelated_histories,
539 N_("allow merging unrelated histories"),
540 PARSE_OPT_NONEG),
ec1edbcb
EN
541 OPT_BOOL_F(0, "stdin",
542 &o.use_stdin,
543 N_("perform multiple merges, one per line of input"),
544 PARSE_OPT_NONEG),
66265a69
KZ
545 OPT_STRING(0, "merge-base",
546 &merge_base,
547 N_("commit"),
548 N_("specify a merge-base for the merge")),
6ec755a0
EN
549 OPT_END()
550 };
551
552 /* Parse arguments */
a1a78119 553 original_argc = argc - 1; /* ignoring argv[0] */
6ec755a0
EN
554 argc = parse_options(argc, argv, prefix, mt_options,
555 merge_tree_usage, PARSE_OPT_STOP_AT_NON_OPTION);
ec1edbcb
EN
556
557 /* Handle --stdin */
558 if (o.use_stdin) {
559 struct strbuf buf = STRBUF_INIT;
560
561 if (o.mode == MODE_TRIVIAL)
562 die(_("--trivial-merge is incompatible with all other options"));
66265a69
KZ
563 if (merge_base)
564 die(_("--merge-base is incompatible with --stdin"));
ec1edbcb
EN
565 line_termination = '\0';
566 while (strbuf_getline_lf(&buf, stdin) != EOF) {
567 struct strbuf **split;
568 int result;
501e3bab 569 const char *input_merge_base = NULL;
ec1edbcb
EN
570
571 split = strbuf_split(&buf, ' ');
501e3bab 572 if (!split[0] || !split[1])
ec1edbcb
EN
573 die(_("malformed input line: '%s'."), buf.buf);
574 strbuf_rtrim(split[0]);
501e3bab
KZ
575 strbuf_rtrim(split[1]);
576
577 /* parse the merge-base */
578 if (!strcmp(split[1]->buf, "--")) {
579 input_merge_base = split[0]->buf;
580 }
581
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);
588 } else {
589 die(_("malformed input line: '%s'."), buf.buf);
590 }
591
ec1edbcb
EN
592 if (result < 0)
593 die(_("merging cannot continue; got unclean result of %d"), result);
594 strbuf_list_free(split);
595 }
596 strbuf_release(&buf);
597 return 0;
598 }
599
600 /* Figure out which mode to use */
6ec755a0
EN
601 switch (o.mode) {
602 default:
603 BUG("unexpected command mode %d", o.mode);
604 case MODE_UNKNOWN:
605 switch (argc) {
606 default:
607 usage_with_options(merge_tree_usage, mt_options);
608 case 2:
609 o.mode = MODE_REAL;
610 break;
611 case 3:
612 o.mode = MODE_TRIVIAL;
613 break;
614 }
615 expected_remaining_argc = argc;
616 break;
617 case MODE_REAL:
618 expected_remaining_argc = 2;
619 break;
620 case MODE_TRIVIAL:
621 expected_remaining_argc = 3;
a1a78119
EN
622 /* Removal of `--trivial-merge` is expected */
623 original_argc--;
6ec755a0
EN
624 break;
625 }
a1a78119
EN
626 if (o.mode == MODE_TRIVIAL && argc < original_argc)
627 die(_("--trivial-merge is incompatible with all other options"));
6ec755a0
EN
628
629 if (argc != expected_remaining_argc)
630 usage_with_options(merge_tree_usage, mt_options);
631
b6551fea
DS
632 git_config(git_default_config, NULL);
633
6ec755a0
EN
634 /* Do the relevant type of merge */
635 if (o.mode == MODE_REAL)
66265a69 636 return real_merge(&o, merge_base, argv[0], argv[1], prefix);
6ec755a0
EN
637 else
638 return trivial_merge(argv[0], argv[1], argv[2]);
55e48f6b 639}