@matheusbsbs / matheus-bagliano / commits / 9047ebbc22

Fork 0

Split out merge_recursive() to merge-recursive.c

Move most of the of code from builtin-merge-recursive.c to a new file merge-recursive.c and introduce merge_recursive_setup() in there so that builtin-merge-recursive and other builtins call it. Signed-off-by: Miklos Vajna <vmiklos@frugalware.org> Signed-off-by: Junio C Hamano <gitster@pobox.com>

Miklos Vajna committed Aug 12, 2008 at 18:45 UTC 9047ebbc229bf5b99d6c7522293b8cbd1100b747

4 files changed +1341 -1324

Makefile

@@ -440,6 +440,7 @@ LIB_OBJS += log-tree.o

440 LIB_OBJS += mailmap.o

441 LIB_OBJS += match-trees.o

442 LIB_OBJS += merge-file.o

443 +LIB_OBJS += merge-recursive.o

444 LIB_OBJS += name-hash.o

445 LIB_OBJS += object.o

446 LIB_OBJS += pack-check.o

builtin-merge-recursive.c

+4 -1323

@@ -1,1307 +1,8 @@

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 - */

1 #include "cache.h"

7 -#include "cache-tree.h"

2 #include "commit.h"

9 -#include "blob.h"

10 -#include "builtin.h"

11 -#include "tree-walk.h"

12 -#include "diff.h"

13 -#include "diffcore.h"

3 #include "tag.h"

15 -#include "unpack-trees.h"

16 -#include "string-list.h"

17 -#include "xdiff-interface.h"

18 -#include "ll-merge.h"

19 -#include "interpolate.h"

20 -#include "attr.h"

4 #include "merge-recursive.h"

23 -static int subtree_merge;

24 -

25 -static struct tree *shift_tree_object(struct tree *one, struct tree *two)

26 -{

27 - unsigned char shifted[20];

28 -

29 - /*

30 - * NEEDSWORK: this limits the recursion depth to hardcoded

31 - * value '2' to avoid excessive overhead.

32 - */

33 - shift_tree(one->object.sha1, two->object.sha1, shifted, 2);

34 - if (!hashcmp(two->object.sha1, shifted))

35 - return two;

36 - return lookup_tree(shifted);

37 -}

38 -

39 -/*

40 - * A virtual commit has

41 - * - (const char *)commit->util set to the name, and

42 - * - *(int *)commit->object.sha1 set to the virtual id.

43 - */

44 -

45 -static struct commit *make_virtual_commit(struct tree *tree, const char *comment)

46 -{

47 - struct commit *commit = xcalloc(1, sizeof(struct commit));

48 - static unsigned virtual_id = 1;

49 - commit->tree = tree;

50 - commit->util = (void*)comment;

51 - *(int*)commit->object.sha1 = virtual_id++;

52 - /* avoid warnings */

53 - commit->object.parsed = 1;

54 - return commit;

55 -}

56 -

57 -/*

58 - * Since we use get_tree_entry(), which does not put the read object into

59 - * the object pool, we cannot rely on a == b.

60 - */

61 -static int sha_eq(const unsigned char *a, const unsigned char *b)

62 -{

63 - if (!a && !b)

64 - return 2;

65 - return a && b && hashcmp(a, b) == 0;

66 -}

67 -

68 -/*

69 - * Since we want to write the index eventually, we cannot reuse the index

70 - * for these (temporary) data.

71 - */

72 -struct stage_data

73 -{

74 - struct

75 - {

76 - unsigned mode;

77 - unsigned char sha[20];

78 - } stages[4];

79 - unsigned processed:1;

80 -};

81 -

82 -static struct string_list current_file_set = {NULL, 0, 0, 1};

83 -static struct string_list current_directory_set = {NULL, 0, 0, 1};

84 -

85 -static int call_depth = 0;

86 -static int verbosity = 2;

87 -static int diff_rename_limit = -1;

88 -static int merge_rename_limit = -1;

89 -static int buffer_output = 1;

90 -static struct strbuf obuf = STRBUF_INIT;

91 -

92 -static int show(int v)

93 -{

94 - return (!call_depth && verbosity >= v) || verbosity >= 5;

95 -}

96 -

97 -static void flush_output(void)

98 -{

99 - if (obuf.len) {

100 - fputs(obuf.buf, stdout);

101 - strbuf_reset(&obuf);

102 - }

103 -}

104 -

105 -static void output(int v, const char *fmt, ...)

106 -{

107 - int len;

108 - va_list ap;

109 -

110 - if (!show(v))

111 - return;

112 -

113 - strbuf_grow(&obuf, call_depth * 2 + 2);

114 - memset(obuf.buf + obuf.len, ' ', call_depth * 2);

115 - strbuf_setlen(&obuf, obuf.len + call_depth * 2);

116 -

117 - va_start(ap, fmt);

118 - len = vsnprintf(obuf.buf + obuf.len, strbuf_avail(&obuf), fmt, ap);

119 - va_end(ap);

120 -

121 - if (len < 0)

122 - len = 0;

123 - if (len >= strbuf_avail(&obuf)) {

124 - strbuf_grow(&obuf, len + 2);

125 - va_start(ap, fmt);

126 - len = vsnprintf(obuf.buf + obuf.len, strbuf_avail(&obuf), fmt, ap);

127 - va_end(ap);

128 - if (len >= strbuf_avail(&obuf)) {

129 - die("this should not happen, your snprintf is broken");

130 - }

131 - }

132 - strbuf_setlen(&obuf, obuf.len + len);

133 - strbuf_add(&obuf, "\n", 1);

134 - if (!buffer_output)

135 - flush_output();

136 -}

137 -

138 -static void output_commit_title(struct commit *commit)

139 -{

140 - int i;

141 - flush_output();

142 - for (i = call_depth; i--;)

143 - fputs(" ", stdout);

144 - if (commit->util)

145 - printf("virtual %s\n", (char *)commit->util);

146 - else {

147 - printf("%s ", find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV));

148 - if (parse_commit(commit) != 0)

149 - printf("(bad commit)\n");

150 - else {

151 - const char *s;

152 - int len;

153 - for (s = commit->buffer; *s; s++)

154 - if (*s == '\n' && s[1] == '\n') {

155 - s += 2;

156 - break;

157 - }

158 - for (len = 0; s[len] && '\n' != s[len]; len++)

159 - ; /* do nothing */

160 - printf("%.*s\n", len, s);

161 - }

162 - }

163 -}

164 -

165 -static int add_cacheinfo(unsigned int mode, const unsigned char *sha1,

166 - const char *path, int stage, int refresh, int options)

167 -{

168 - struct cache_entry *ce;

169 - ce = make_cache_entry(mode, sha1 ? sha1 : null_sha1, path, stage, refresh);

170 - if (!ce)

171 - return error("addinfo_cache failed for path '%s'", path);

172 - return add_cache_entry(ce, options);

173 -}

174 -

175 -/*

176 - * This is a global variable which is used in a number of places but

177 - * only written to in the 'merge' function.

178 - *

179 - * index_only == 1 => Don't leave any non-stage 0 entries in the cache and

180 - * don't update the working directory.

181 - * 0 => Leave unmerged entries in the cache and update

182 - * the working directory.

183 - */

184 -static int index_only = 0;

185 -

186 -static void init_tree_desc_from_tree(struct tree_desc *desc, struct tree *tree)

187 -{

188 - parse_tree(tree);

189 - init_tree_desc(desc, tree->buffer, tree->size);

190 -}

191 -

192 -static int git_merge_trees(int index_only,

193 - struct tree *common,

194 - struct tree *head,

195 - struct tree *merge)

196 -{

197 - int rc;

198 - struct tree_desc t[3];

199 - struct unpack_trees_options opts;

200 -

201 - memset(&opts, 0, sizeof(opts));

202 - if (index_only)

203 - opts.index_only = 1;

204 - else

205 - opts.update = 1;

206 - opts.merge = 1;

207 - opts.head_idx = 2;

208 - opts.fn = threeway_merge;

209 - opts.src_index = &the_index;

210 - opts.dst_index = &the_index;

211 -

212 - init_tree_desc_from_tree(t+0, common);

213 - init_tree_desc_from_tree(t+1, head);

214 - init_tree_desc_from_tree(t+2, merge);

215 -

216 - rc = unpack_trees(3, t, &opts);

217 - cache_tree_free(&active_cache_tree);

218 - return rc;

219 -}

220 -

221 -struct tree *write_tree_from_memory(void)

222 -{

223 - struct tree *result = NULL;

224 -

225 - if (unmerged_cache()) {

226 - int i;

227 - output(0, "There are unmerged index entries:");

228 - for (i = 0; i < active_nr; i++) {

229 - struct cache_entry *ce = active_cache[i];

230 - if (ce_stage(ce))

231 - output(0, "%d %.*s", ce_stage(ce), ce_namelen(ce), ce->name);

232 - }

233 - return NULL;

234 - }

235 -

236 - if (!active_cache_tree)

237 - active_cache_tree = cache_tree();

238 -

239 - if (!cache_tree_fully_valid(active_cache_tree) &&

240 - cache_tree_update(active_cache_tree,

241 - active_cache, active_nr, 0, 0) < 0)

242 - die("error building trees");

243 -

244 - result = lookup_tree(active_cache_tree->sha1);

245 -

246 - return result;

247 -}

248 -

249 -static int save_files_dirs(const unsigned char *sha1,

250 - const char *base, int baselen, const char *path,

251 - unsigned int mode, int stage, void *context)

252 -{

253 - int len = strlen(path);

254 - char *newpath = xmalloc(baselen + len + 1);

255 - memcpy(newpath, base, baselen);

256 - memcpy(newpath + baselen, path, len);

257 - newpath[baselen + len] = '\0';

258 -

259 - if (S_ISDIR(mode))

260 - string_list_insert(newpath, &current_directory_set);

261 - else

262 - string_list_insert(newpath, &current_file_set);

263 - free(newpath);

264 -

265 - return READ_TREE_RECURSIVE;

266 -}

267 -

268 -static int get_files_dirs(struct tree *tree)

269 -{

270 - int n;

271 - if (read_tree_recursive(tree, "", 0, 0, NULL, save_files_dirs, NULL))

272 - return 0;

273 - n = current_file_set.nr + current_directory_set.nr;

274 - return n;

275 -}

276 -

277 -/*

278 - * Returns an index_entry instance which doesn't have to correspond to

279 - * a real cache entry in Git's index.

280 - */

281 -static struct stage_data *insert_stage_data(const char *path,

282 - struct tree *o, struct tree *a, struct tree *b,

283 - struct string_list *entries)

284 -{

285 - struct string_list_item *item;

286 - struct stage_data *e = xcalloc(1, sizeof(struct stage_data));

287 - get_tree_entry(o->object.sha1, path,

288 - e->stages[1].sha, &e->stages[1].mode);

289 - get_tree_entry(a->object.sha1, path,

290 - e->stages[2].sha, &e->stages[2].mode);

291 - get_tree_entry(b->object.sha1, path,

292 - e->stages[3].sha, &e->stages[3].mode);

293 - item = string_list_insert(path, entries);

294 - item->util = e;

295 - return e;

296 -}

297 -

298 -/*

299 - * Create a dictionary mapping file names to stage_data objects. The

300 - * dictionary contains one entry for every path with a non-zero stage entry.

301 - */

302 -static struct string_list *get_unmerged(void)

303 -{

304 - struct string_list *unmerged = xcalloc(1, sizeof(struct string_list));

305 - int i;

306 -

307 - unmerged->strdup_strings = 1;

308 -

309 - for (i = 0; i < active_nr; i++) {

310 - struct string_list_item *item;

311 - struct stage_data *e;

312 - struct cache_entry *ce = active_cache[i];

313 - if (!ce_stage(ce))

314 - continue;

315 -

316 - item = string_list_lookup(ce->name, unmerged);

317 - if (!item) {

318 - item = string_list_insert(ce->name, unmerged);

319 - item->util = xcalloc(1, sizeof(struct stage_data));

320 - }

321 - e = item->util;

322 - e->stages[ce_stage(ce)].mode = ce->ce_mode;

323 - hashcpy(e->stages[ce_stage(ce)].sha, ce->sha1);

324 - }

325 -

326 - return unmerged;

327 -}

328 -

329 -struct rename

330 -{

331 - struct diff_filepair *pair;

332 - struct stage_data *src_entry;

333 - struct stage_data *dst_entry;

334 - unsigned processed:1;

335 -};

336 -

337 -/*

338 - * Get information of all renames which occurred between 'o_tree' and

339 - * 'tree'. We need the three trees in the merge ('o_tree', 'a_tree' and

340 - * 'b_tree') to be able to associate the correct cache entries with

341 - * the rename information. 'tree' is always equal to either a_tree or b_tree.

342 - */

343 -static struct string_list *get_renames(struct tree *tree,

344 - struct tree *o_tree,

345 - struct tree *a_tree,

346 - struct tree *b_tree,

347 - struct string_list *entries)

348 -{

349 - int i;

350 - struct string_list *renames;

351 - struct diff_options opts;

352 -

353 - renames = xcalloc(1, sizeof(struct string_list));

354 - diff_setup(&opts);

355 - DIFF_OPT_SET(&opts, RECURSIVE);

356 - opts.detect_rename = DIFF_DETECT_RENAME;

357 - opts.rename_limit = merge_rename_limit >= 0 ? merge_rename_limit :

358 - diff_rename_limit >= 0 ? diff_rename_limit :

359 - 500;

360 - opts.warn_on_too_large_rename = 1;

361 - opts.output_format = DIFF_FORMAT_NO_OUTPUT;

362 - if (diff_setup_done(&opts) < 0)

363 - die("diff setup failed");

364 - diff_tree_sha1(o_tree->object.sha1, tree->object.sha1, "", &opts);

365 - diffcore_std(&opts);

366 - for (i = 0; i < diff_queued_diff.nr; ++i) {

367 - struct string_list_item *item;

368 - struct rename *re;

369 - struct diff_filepair *pair = diff_queued_diff.queue[i];

370 - if (pair->status != 'R') {

371 - diff_free_filepair(pair);

372 - continue;

373 - }

374 - re = xmalloc(sizeof(*re));

375 - re->processed = 0;

376 - re->pair = pair;

377 - item = string_list_lookup(re->pair->one->path, entries);

378 - if (!item)

379 - re->src_entry = insert_stage_data(re->pair->one->path,

380 - o_tree, a_tree, b_tree, entries);

381 - else

382 - re->src_entry = item->util;

383 -

384 - item = string_list_lookup(re->pair->two->path, entries);

385 - if (!item)

386 - re->dst_entry = insert_stage_data(re->pair->two->path,

387 - o_tree, a_tree, b_tree, entries);

388 - else

389 - re->dst_entry = item->util;

390 - item = string_list_insert(pair->one->path, renames);

391 - item->util = re;

392 - }

393 - opts.output_format = DIFF_FORMAT_NO_OUTPUT;

394 - diff_queued_diff.nr = 0;

395 - diff_flush(&opts);

396 - return renames;

397 -}

398 -

399 -static int update_stages(const char *path, struct diff_filespec *o,

400 - struct diff_filespec *a, struct diff_filespec *b,

401 - int clear)

402 -{

403 - int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE;

404 - if (clear)

405 - if (remove_file_from_cache(path))

406 - return -1;

407 - if (o)

408 - if (add_cacheinfo(o->mode, o->sha1, path, 1, 0, options))

409 - return -1;

410 - if (a)

411 - if (add_cacheinfo(a->mode, a->sha1, path, 2, 0, options))

412 - return -1;

413 - if (b)

414 - if (add_cacheinfo(b->mode, b->sha1, path, 3, 0, options))

415 - return -1;

416 - return 0;

417 -}

418 -

419 -static int remove_path(const char *name)

420 -{

421 - int ret;

422 - char *slash, *dirs;

423 -

424 - ret = unlink(name);

425 - if (ret)

426 - return ret;

427 - dirs = xstrdup(name);

428 - while ((slash = strrchr(name, '/'))) {

429 - *slash = '\0';

430 - if (rmdir(name) != 0)

431 - break;

432 - }

433 - free(dirs);

434 - return ret;

435 -}

436 -

437 -static int remove_file(int clean, const char *path, int no_wd)

438 -{

439 - int update_cache = index_only || clean;

440 - int update_working_directory = !index_only && !no_wd;

441 -

442 - if (update_cache) {

443 - if (remove_file_from_cache(path))

444 - return -1;

445 - }

446 - if (update_working_directory) {

447 - unlink(path);

448 - if (errno != ENOENT || errno != EISDIR)

449 - return -1;

450 - remove_path(path);

451 - }

452 - return 0;

453 -}

454 -

455 -static char *unique_path(const char *path, const char *branch)

456 -{

457 - char *newpath = xmalloc(strlen(path) + 1 + strlen(branch) + 8 + 1);

458 - int suffix = 0;

459 - struct stat st;

460 - char *p = newpath + strlen(path);

461 - strcpy(newpath, path);

462 - *(p++) = '~';

463 - strcpy(p, branch);

464 - for (; *p; ++p)

465 - if ('/' == *p)

466 - *p = '_';

467 - while (string_list_has_string(&current_file_set, newpath) ||

468 - string_list_has_string(&current_directory_set, newpath) ||

469 - lstat(newpath, &st) == 0)

470 - sprintf(p, "_%d", suffix++);

471 -

472 - string_list_insert(newpath, &current_file_set);

473 - return newpath;

474 -}

475 -

476 -static void flush_buffer(int fd, const char *buf, unsigned long size)

477 -{

478 - while (size > 0) {

479 - long ret = write_in_full(fd, buf, size);

480 - if (ret < 0) {

481 - /* Ignore epipe */

482 - if (errno == EPIPE)

483 - break;

484 - die("merge-recursive: %s", strerror(errno));

485 - } else if (!ret) {

486 - die("merge-recursive: disk full?");

487 - }

488 - size -= ret;

489 - buf += ret;

490 - }

491 -}

492 -

493 -static int make_room_for_path(const char *path)

494 -{

495 - int status;

496 - const char *msg = "failed to create path '%s'%s";

497 -

498 - status = safe_create_leading_directories_const(path);

499 - if (status) {

500 - if (status == -3) {

501 - /* something else exists */

502 - error(msg, path, ": perhaps a D/F conflict?");

503 - return -1;

504 - }

505 - die(msg, path, "");

506 - }

507 -

508 - /* Successful unlink is good.. */

509 - if (!unlink(path))

510 - return 0;

511 - /* .. and so is no existing file */

512 - if (errno == ENOENT)

513 - return 0;

514 - /* .. but not some other error (who really cares what?) */

515 - return error(msg, path, ": perhaps a D/F conflict?");

516 -}

517 -

518 -static void update_file_flags(const unsigned char *sha,

519 - unsigned mode,

520 - const char *path,

521 - int update_cache,

522 - int update_wd)

523 -{

524 - if (index_only)

525 - update_wd = 0;

526 -

527 - if (update_wd) {

528 - enum object_type type;

529 - void *buf;

530 - unsigned long size;

531 -

532 - if (S_ISGITLINK(mode))

533 - die("cannot read object %s '%s': It is a submodule!",

534 - sha1_to_hex(sha), path);

535 -

536 - buf = read_sha1_file(sha, &type, &size);

537 - if (!buf)

538 - die("cannot read object %s '%s'", sha1_to_hex(sha), path);

539 - if (type != OBJ_BLOB)

540 - die("blob expected for %s '%s'", sha1_to_hex(sha), path);

541 - if (S_ISREG(mode)) {

542 - struct strbuf strbuf;

543 - strbuf_init(&strbuf, 0);

544 - if (convert_to_working_tree(path, buf, size, &strbuf)) {

545 - free(buf);

546 - size = strbuf.len;

547 - buf = strbuf_detach(&strbuf, NULL);

548 - }

549 - }

550 -

551 - if (make_room_for_path(path) < 0) {

552 - update_wd = 0;

553 - free(buf);

554 - goto update_index;

555 - }

556 - if (S_ISREG(mode) || (!has_symlinks && S_ISLNK(mode))) {

557 - int fd;

558 - if (mode & 0100)

559 - mode = 0777;

560 - else

561 - mode = 0666;

562 - fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);

563 - if (fd < 0)

564 - die("failed to open %s: %s", path, strerror(errno));

565 - flush_buffer(fd, buf, size);

566 - close(fd);

567 - } else if (S_ISLNK(mode)) {

568 - char *lnk = xmemdupz(buf, size);

569 - safe_create_leading_directories_const(path);

570 - unlink(path);

571 - symlink(lnk, path);

572 - free(lnk);

573 - } else

574 - die("do not know what to do with %06o %s '%s'",

575 - mode, sha1_to_hex(sha), path);

576 - free(buf);

577 - }

578 - update_index:

579 - if (update_cache)

580 - add_cacheinfo(mode, sha, path, 0, update_wd, ADD_CACHE_OK_TO_ADD);

581 -}

582 -

583 -static void update_file(int clean,

584 - const unsigned char *sha,

585 - unsigned mode,

586 - const char *path)

587 -{

588 - update_file_flags(sha, mode, path, index_only || clean, !index_only);

589 -}

590 -

591 -/* Low level file merging, update and removal */

592 -

593 -struct merge_file_info

594 -{

595 - unsigned char sha[20];

596 - unsigned mode;

597 - unsigned clean:1,

598 - merge:1;

599 -};

600 -

601 -static void fill_mm(const unsigned char *sha1, mmfile_t *mm)

602 -{

603 - unsigned long size;

604 - enum object_type type;

605 -

606 - if (!hashcmp(sha1, null_sha1)) {

607 - mm->ptr = xstrdup("");

608 - mm->size = 0;

609 - return;

610 - }

611 -

612 - mm->ptr = read_sha1_file(sha1, &type, &size);

613 - if (!mm->ptr || type != OBJ_BLOB)

614 - die("unable to read blob object %s", sha1_to_hex(sha1));

615 - mm->size = size;

616 -}

617 -

618 -static int merge_3way(mmbuffer_t *result_buf,

619 - struct diff_filespec *o,

620 - struct diff_filespec *a,

621 - struct diff_filespec *b,

622 - const char *branch1,

623 - const char *branch2)

624 -{

625 - mmfile_t orig, src1, src2;

626 - char *name1, *name2;

627 - int merge_status;

628 -

629 - name1 = xstrdup(mkpath("%s:%s", branch1, a->path));

630 - name2 = xstrdup(mkpath("%s:%s", branch2, b->path));

631 -

632 - fill_mm(o->sha1, &orig);

633 - fill_mm(a->sha1, &src1);

634 - fill_mm(b->sha1, &src2);

635 -

636 - merge_status = ll_merge(result_buf, a->path, &orig,

637 - &src1, name1, &src2, name2,

638 - index_only);

639 -

640 - free(name1);

641 - free(name2);

642 - free(orig.ptr);

643 - free(src1.ptr);

644 - free(src2.ptr);

645 - return merge_status;

646 -}

647 -

648 -static struct merge_file_info merge_file(struct diff_filespec *o,

649 - struct diff_filespec *a, struct diff_filespec *b,

650 - const char *branch1, const char *branch2)

651 -{

652 - struct merge_file_info result;

653 - result.merge = 0;

654 - result.clean = 1;

655 -

656 - if ((S_IFMT & a->mode) != (S_IFMT & b->mode)) {

657 - result.clean = 0;

658 - if (S_ISREG(a->mode)) {

659 - result.mode = a->mode;

660 - hashcpy(result.sha, a->sha1);

661 - } else {

662 - result.mode = b->mode;

663 - hashcpy(result.sha, b->sha1);

664 - }

665 - } else {

666 - if (!sha_eq(a->sha1, o->sha1) && !sha_eq(b->sha1, o->sha1))

667 - result.merge = 1;

668 -

669 - /*

670 - * Merge modes

671 - */

672 - if (a->mode == b->mode || a->mode == o->mode)

673 - result.mode = b->mode;

674 - else {

675 - result.mode = a->mode;

676 - if (b->mode != o->mode) {

677 - result.clean = 0;

678 - result.merge = 1;

679 - }

680 - }

681 -

682 - if (sha_eq(a->sha1, b->sha1) || sha_eq(a->sha1, o->sha1))

683 - hashcpy(result.sha, b->sha1);

684 - else if (sha_eq(b->sha1, o->sha1))

685 - hashcpy(result.sha, a->sha1);

686 - else if (S_ISREG(a->mode)) {

687 - mmbuffer_t result_buf;

688 - int merge_status;

689 -

690 - merge_status = merge_3way(&result_buf, o, a, b,

691 - branch1, branch2);

692 -

693 - if ((merge_status < 0) || !result_buf.ptr)

694 - die("Failed to execute internal merge");

695 -

696 - if (write_sha1_file(result_buf.ptr, result_buf.size,

697 - blob_type, result.sha))

698 - die("Unable to add %s to database",

699 - a->path);

700 -

701 - free(result_buf.ptr);

702 - result.clean = (merge_status == 0);

703 - } else if (S_ISGITLINK(a->mode)) {

704 - result.clean = 0;

705 - hashcpy(result.sha, a->sha1);

706 - } else if (S_ISLNK(a->mode)) {

707 - hashcpy(result.sha, a->sha1);

708 -

709 - if (!sha_eq(a->sha1, b->sha1))

710 - result.clean = 0;

711 - } else {

712 - die("unsupported object type in the tree");

713 - }

714 - }

715 -

716 - return result;

717 -}

718 -

719 -static void conflict_rename_rename(struct rename *ren1,

720 - const char *branch1,

721 - struct rename *ren2,

722 - const char *branch2)

723 -{

724 - char *del[2];

725 - int delp = 0;

726 - const char *ren1_dst = ren1->pair->two->path;

727 - const char *ren2_dst = ren2->pair->two->path;

728 - const char *dst_name1 = ren1_dst;

729 - const char *dst_name2 = ren2_dst;

730 - if (string_list_has_string(&current_directory_set, ren1_dst)) {

731 - dst_name1 = del[delp++] = unique_path(ren1_dst, branch1);

732 - output(1, "%s is a directory in %s adding as %s instead",

733 - ren1_dst, branch2, dst_name1);

734 - remove_file(0, ren1_dst, 0);

735 - }

736 - if (string_list_has_string(&current_directory_set, ren2_dst)) {

737 - dst_name2 = del[delp++] = unique_path(ren2_dst, branch2);

738 - output(1, "%s is a directory in %s adding as %s instead",

739 - ren2_dst, branch1, dst_name2);

740 - remove_file(0, ren2_dst, 0);

741 - }

742 - if (index_only) {

743 - remove_file_from_cache(dst_name1);

744 - remove_file_from_cache(dst_name2);

745 - /*

746 - * Uncomment to leave the conflicting names in the resulting tree

747 - *

748 - * update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, dst_name1);

749 - * update_file(0, ren2->pair->two->sha1, ren2->pair->two->mode, dst_name2);

750 - */

751 - } else {

752 - update_stages(dst_name1, NULL, ren1->pair->two, NULL, 1);

753 - update_stages(dst_name2, NULL, NULL, ren2->pair->two, 1);

754 - }

755 - while (delp--)

756 - free(del[delp]);

757 -}

758 -

759 -static void conflict_rename_dir(struct rename *ren1,

760 - const char *branch1)

761 -{

762 - char *new_path = unique_path(ren1->pair->two->path, branch1);

763 - output(1, "Renaming %s to %s instead", ren1->pair->one->path, new_path);

764 - remove_file(0, ren1->pair->two->path, 0);

765 - update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, new_path);

766 - free(new_path);

767 -}

768 -

769 -static void conflict_rename_rename_2(struct rename *ren1,

770 - const char *branch1,

771 - struct rename *ren2,

772 - const char *branch2)

773 -{

774 - char *new_path1 = unique_path(ren1->pair->two->path, branch1);

775 - char *new_path2 = unique_path(ren2->pair->two->path, branch2);

776 - output(1, "Renaming %s to %s and %s to %s instead",

777 - ren1->pair->one->path, new_path1,

778 - ren2->pair->one->path, new_path2);

779 - remove_file(0, ren1->pair->two->path, 0);

780 - update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, new_path1);

781 - update_file(0, ren2->pair->two->sha1, ren2->pair->two->mode, new_path2);

782 - free(new_path2);

783 - free(new_path1);

784 -}

785 -

786 -static int process_renames(struct string_list *a_renames,

787 - struct string_list *b_renames,

788 - const char *a_branch,

789 - const char *b_branch)

790 -{

791 - int clean_merge = 1, i, j;

792 - struct string_list a_by_dst = {NULL, 0, 0, 0}, b_by_dst = {NULL, 0, 0, 0};

793 - const struct rename *sre;

794 -

795 - for (i = 0; i < a_renames->nr; i++) {

796 - sre = a_renames->items[i].util;

797 - string_list_insert(sre->pair->two->path, &a_by_dst)->util

798 - = sre->dst_entry;

799 - }

800 - for (i = 0; i < b_renames->nr; i++) {

801 - sre = b_renames->items[i].util;

802 - string_list_insert(sre->pair->two->path, &b_by_dst)->util

803 - = sre->dst_entry;

804 - }

805 -

806 - for (i = 0, j = 0; i < a_renames->nr || j < b_renames->nr;) {

807 - int compare;

808 - char *src;

809 - struct string_list *renames1, *renames2, *renames2Dst;

810 - struct rename *ren1 = NULL, *ren2 = NULL;

811 - const char *branch1, *branch2;

812 - const char *ren1_src, *ren1_dst;

813 -

814 - if (i >= a_renames->nr) {

815 - compare = 1;

816 - ren2 = b_renames->items[j++].util;

817 - } else if (j >= b_renames->nr) {

818 - compare = -1;

819 - ren1 = a_renames->items[i++].util;

820 - } else {

821 - compare = strcmp(a_renames->items[i].string,

822 - b_renames->items[j].string);

823 - if (compare <= 0)

824 - ren1 = a_renames->items[i++].util;

825 - if (compare >= 0)

826 - ren2 = b_renames->items[j++].util;

827 - }

828 -

829 - /* TODO: refactor, so that 1/2 are not needed */

830 - if (ren1) {

831 - renames1 = a_renames;

832 - renames2 = b_renames;

833 - renames2Dst = &b_by_dst;

834 - branch1 = a_branch;

835 - branch2 = b_branch;

836 - } else {

837 - struct rename *tmp;

838 - renames1 = b_renames;

839 - renames2 = a_renames;

840 - renames2Dst = &a_by_dst;

841 - branch1 = b_branch;

842 - branch2 = a_branch;

843 - tmp = ren2;

844 - ren2 = ren1;

845 - ren1 = tmp;

846 - }

847 - src = ren1->pair->one->path;

848 -

849 - ren1->dst_entry->processed = 1;

850 - ren1->src_entry->processed = 1;

851 -

852 - if (ren1->processed)

853 - continue;

854 - ren1->processed = 1;

855 -

856 - ren1_src = ren1->pair->one->path;

857 - ren1_dst = ren1->pair->two->path;

858 -

859 - if (ren2) {

860 - const char *ren2_src = ren2->pair->one->path;

861 - const char *ren2_dst = ren2->pair->two->path;

862 - /* Renamed in 1 and renamed in 2 */

863 - if (strcmp(ren1_src, ren2_src) != 0)

864 - die("ren1.src != ren2.src");

865 - ren2->dst_entry->processed = 1;

866 - ren2->processed = 1;

867 - if (strcmp(ren1_dst, ren2_dst) != 0) {

868 - clean_merge = 0;

869 - output(1, "CONFLICT (rename/rename): "

870 - "Rename \"%s\"->\"%s\" in branch \"%s\" "

871 - "rename \"%s\"->\"%s\" in \"%s\"%s",

872 - src, ren1_dst, branch1,

873 - src, ren2_dst, branch2,

874 - index_only ? " (left unresolved)": "");

875 - if (index_only) {

876 - remove_file_from_cache(src);

877 - update_file(0, ren1->pair->one->sha1,

878 - ren1->pair->one->mode, src);

879 - }

880 - conflict_rename_rename(ren1, branch1, ren2, branch2);

881 - } else {

882 - struct merge_file_info mfi;

883 - remove_file(1, ren1_src, 1);

884 - mfi = merge_file(ren1->pair->one,

885 - ren1->pair->two,

886 - ren2->pair->two,

887 - branch1,

888 - branch2);

889 - if (mfi.merge || !mfi.clean)

890 - output(1, "Renaming %s->%s", src, ren1_dst);

891 -

892 - if (mfi.merge)

893 - output(2, "Auto-merging %s", ren1_dst);

894 -

895 - if (!mfi.clean) {

896 - output(1, "CONFLICT (content): merge conflict in %s",

897 - ren1_dst);

898 - clean_merge = 0;

899 -

900 - if (!index_only)

901 - update_stages(ren1_dst,

902 - ren1->pair->one,

903 - ren1->pair->two,

904 - ren2->pair->two,

905 - 1 /* clear */);

906 - }

907 - update_file(mfi.clean, mfi.sha, mfi.mode, ren1_dst);

908 - }

909 - } else {

910 - /* Renamed in 1, maybe changed in 2 */

911 - struct string_list_item *item;

912 - /* we only use sha1 and mode of these */

913 - struct diff_filespec src_other, dst_other;

914 - int try_merge, stage = a_renames == renames1 ? 3: 2;

915 -

916 - remove_file(1, ren1_src, index_only || stage == 3);

917 -

918 - hashcpy(src_other.sha1, ren1->src_entry->stages[stage].sha);

919 - src_other.mode = ren1->src_entry->stages[stage].mode;

920 - hashcpy(dst_other.sha1, ren1->dst_entry->stages[stage].sha);

921 - dst_other.mode = ren1->dst_entry->stages[stage].mode;

922 -

923 - try_merge = 0;

924 -

925 - if (string_list_has_string(&current_directory_set, ren1_dst)) {

926 - clean_merge = 0;

927 - output(1, "CONFLICT (rename/directory): Rename %s->%s in %s "

928 - " directory %s added in %s",

929 - ren1_src, ren1_dst, branch1,

930 - ren1_dst, branch2);

931 - conflict_rename_dir(ren1, branch1);

932 - } else if (sha_eq(src_other.sha1, null_sha1)) {

933 - clean_merge = 0;

934 - output(1, "CONFLICT (rename/delete): Rename %s->%s in %s "

935 - "and deleted in %s",

936 - ren1_src, ren1_dst, branch1,

937 - branch2);

938 - update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, ren1_dst);

939 - } else if (!sha_eq(dst_other.sha1, null_sha1)) {

940 - const char *new_path;

941 - clean_merge = 0;

942 - try_merge = 1;

943 - output(1, "CONFLICT (rename/add): Rename %s->%s in %s. "

944 - "%s added in %s",

945 - ren1_src, ren1_dst, branch1,

946 - ren1_dst, branch2);

947 - new_path = unique_path(ren1_dst, branch2);

948 - output(1, "Adding as %s instead", new_path);

949 - update_file(0, dst_other.sha1, dst_other.mode, new_path);

950 - } else if ((item = string_list_lookup(ren1_dst, renames2Dst))) {

951 - ren2 = item->util;

952 - clean_merge = 0;

953 - ren2->processed = 1;

954 - output(1, "CONFLICT (rename/rename): Rename %s->%s in %s. "

955 - "Rename %s->%s in %s",

956 - ren1_src, ren1_dst, branch1,

957 - ren2->pair->one->path, ren2->pair->two->path, branch2);

958 - conflict_rename_rename_2(ren1, branch1, ren2, branch2);

959 - } else

960 - try_merge = 1;

961 -

962 - if (try_merge) {

963 - struct diff_filespec *o, *a, *b;

964 - struct merge_file_info mfi;

965 - src_other.path = (char *)ren1_src;

966 -

967 - o = ren1->pair->one;

968 - if (a_renames == renames1) {

969 - a = ren1->pair->two;

970 - b = &src_other;

971 - } else {

972 - b = ren1->pair->two;

973 - a = &src_other;

974 - }

975 - mfi = merge_file(o, a, b,

976 - a_branch, b_branch);

977 -

978 - if (mfi.clean &&

979 - sha_eq(mfi.sha, ren1->pair->two->sha1) &&

980 - mfi.mode == ren1->pair->two->mode)

981 - /*

982 - * This messaged is part of

983 - * t6022 test. If you change

984 - * it update the test too.

985 - */

986 - output(3, "Skipped %s (merged same as existing)", ren1_dst);

987 - else {

988 - if (mfi.merge || !mfi.clean)

989 - output(1, "Renaming %s => %s", ren1_src, ren1_dst);

990 - if (mfi.merge)

991 - output(2, "Auto-merging %s", ren1_dst);

992 - if (!mfi.clean) {

993 - output(1, "CONFLICT (rename/modify): Merge conflict in %s",

994 - ren1_dst);

995 - clean_merge = 0;

996 -

997 - if (!index_only)

998 - update_stages(ren1_dst,

999 - o, a, b, 1);

1000 - }

1001 - update_file(mfi.clean, mfi.sha, mfi.mode, ren1_dst);

1002 - }

1003 - }

1004 - }

1005 - }

1006 - string_list_clear(&a_by_dst, 0);

1007 - string_list_clear(&b_by_dst, 0);

1008 -

1009 - return clean_merge;

1010 -}

1011 -

1012 -static unsigned char *stage_sha(const unsigned char *sha, unsigned mode)

1013 -{

1014 - return (is_null_sha1(sha) || mode == 0) ? NULL: (unsigned char *)sha;

1015 -}

1016 -

1017 -/* Per entry merge function */

1018 -static int process_entry(const char *path, struct stage_data *entry,

1019 - const char *branch1,

1020 - const char *branch2)

1021 -{

1022 - /*

1023 - printf("processing entry, clean cache: %s\n", index_only ? "yes": "no");

1024 - print_index_entry("\tpath: ", entry);

1025 - */

1026 - int clean_merge = 1;

1027 - unsigned o_mode = entry->stages[1].mode;

1028 - unsigned a_mode = entry->stages[2].mode;

1029 - unsigned b_mode = entry->stages[3].mode;

1030 - unsigned char *o_sha = stage_sha(entry->stages[1].sha, o_mode);

1031 - unsigned char *a_sha = stage_sha(entry->stages[2].sha, a_mode);

1032 - unsigned char *b_sha = stage_sha(entry->stages[3].sha, b_mode);

1033 -

1034 - if (o_sha && (!a_sha || !b_sha)) {

1035 - /* Case A: Deleted in one */

1036 - if ((!a_sha && !b_sha) ||

1037 - (sha_eq(a_sha, o_sha) && !b_sha) ||

1038 - (!a_sha && sha_eq(b_sha, o_sha))) {

1039 - /* Deleted in both or deleted in one and

1040 - * unchanged in the other */

1041 - if (a_sha)

1042 - output(2, "Removing %s", path);

1043 - /* do not touch working file if it did not exist */

1044 - remove_file(1, path, !a_sha);

1045 - } else {

1046 - /* Deleted in one and changed in the other */

1047 - clean_merge = 0;

1048 - if (!a_sha) {

1049 - output(1, "CONFLICT (delete/modify): %s deleted in %s "

1050 - "and modified in %s. Version %s of %s left in tree.",

1051 - path, branch1,

1052 - branch2, branch2, path);

1053 - update_file(0, b_sha, b_mode, path);

1054 - } else {

1055 - output(1, "CONFLICT (delete/modify): %s deleted in %s "

1056 - "and modified in %s. Version %s of %s left in tree.",

1057 - path, branch2,

1058 - branch1, branch1, path);

1059 - update_file(0, a_sha, a_mode, path);

1060 - }

1061 - }

1062 -

1063 - } else if ((!o_sha && a_sha && !b_sha) ||

1064 - (!o_sha && !a_sha && b_sha)) {

1065 - /* Case B: Added in one. */

1066 - const char *add_branch;

1067 - const char *other_branch;

1068 - unsigned mode;

1069 - const unsigned char *sha;

1070 - const char *conf;

1071 -

1072 - if (a_sha) {

1073 - add_branch = branch1;

1074 - other_branch = branch2;

1075 - mode = a_mode;

1076 - sha = a_sha;

1077 - conf = "file/directory";

1078 - } else {

1079 - add_branch = branch2;

1080 - other_branch = branch1;

1081 - mode = b_mode;

1082 - sha = b_sha;

1083 - conf = "directory/file";

1084 - }

1085 - if (string_list_has_string(&current_directory_set, path)) {

1086 - const char *new_path = unique_path(path, add_branch);

1087 - clean_merge = 0;

1088 - output(1, "CONFLICT (%s): There is a directory with name %s in %s. "

1089 - "Adding %s as %s",

1090 - conf, path, other_branch, path, new_path);

1091 - remove_file(0, path, 0);

1092 - update_file(0, sha, mode, new_path);

1093 - } else {

1094 - output(2, "Adding %s", path);

1095 - update_file(1, sha, mode, path);

1096 - }

1097 - } else if (a_sha && b_sha) {

1098 - /* Case C: Added in both (check for same permissions) and */

1099 - /* case D: Modified in both, but differently. */

1100 - const char *reason = "content";

1101 - struct merge_file_info mfi;

1102 - struct diff_filespec o, a, b;

1103 -

1104 - if (!o_sha) {

1105 - reason = "add/add";

1106 - o_sha = (unsigned char *)null_sha1;

1107 - }

1108 - output(2, "Auto-merging %s", path);

1109 - o.path = a.path = b.path = (char *)path;

1110 - hashcpy(o.sha1, o_sha);

1111 - o.mode = o_mode;

1112 - hashcpy(a.sha1, a_sha);

1113 - a.mode = a_mode;

1114 - hashcpy(b.sha1, b_sha);

1115 - b.mode = b_mode;

1116 -

1117 - mfi = merge_file(&o, &a, &b,

1118 - branch1, branch2);

1119 -

1120 - clean_merge = mfi.clean;

1121 - if (mfi.clean)

1122 - update_file(1, mfi.sha, mfi.mode, path);

1123 - else if (S_ISGITLINK(mfi.mode))

1124 - output(1, "CONFLICT (submodule): Merge conflict in %s "

1125 - "- needs %s", path, sha1_to_hex(b.sha1));

1126 - else {

1127 - output(1, "CONFLICT (%s): Merge conflict in %s",

1128 - reason, path);

1129 -

1130 - if (index_only)

1131 - update_file(0, mfi.sha, mfi.mode, path);

1132 - else

1133 - update_file_flags(mfi.sha, mfi.mode, path,

1134 - 0 /* update_cache */, 1 /* update_working_directory */);

1135 - }

1136 - } else if (!o_sha && !a_sha && !b_sha) {

1137 - /*

1138 - * this entry was deleted altogether. a_mode == 0 means

1139 - * we had that path and want to actively remove it.

1140 - */

1141 - remove_file(1, path, !a_mode);

1142 - } else

1143 - die("Fatal merge failure, shouldn't happen.");

1144 -

1145 - return clean_merge;

1146 -}

1147 -

1148 -int merge_trees(struct tree *head,

1149 - struct tree *merge,

1150 - struct tree *common,

1151 - const char *branch1,

1152 - const char *branch2,

1153 - struct tree **result)

1154 -{

1155 - int code, clean;

1156 -

1157 - if (subtree_merge) {

1158 - merge = shift_tree_object(head, merge);

1159 - common = shift_tree_object(head, common);

1160 - }

1161 -

1162 - if (sha_eq(common->object.sha1, merge->object.sha1)) {

1163 - output(0, "Already uptodate!");

1164 - *result = head;

1165 - return 1;

1166 - }

1167 -

1168 - code = git_merge_trees(index_only, common, head, merge);

1169 -

1170 - if (code != 0)

1171 - die("merging of trees %s and %s failed",

1172 - sha1_to_hex(head->object.sha1),

1173 - sha1_to_hex(merge->object.sha1));

1174 -

1175 - if (unmerged_cache()) {

1176 - struct string_list *entries, *re_head, *re_merge;

1177 - int i;

1178 - string_list_clear(&current_file_set, 1);

1179 - string_list_clear(&current_directory_set, 1);

1180 - get_files_dirs(head);

1181 - get_files_dirs(merge);

1182 -

1183 - entries = get_unmerged();

1184 - re_head = get_renames(head, common, head, merge, entries);

1185 - re_merge = get_renames(merge, common, head, merge, entries);

1186 - clean = process_renames(re_head, re_merge,

1187 - branch1, branch2);

1188 - for (i = 0; i < entries->nr; i++) {

1189 - const char *path = entries->items[i].string;

1190 - struct stage_data *e = entries->items[i].util;

1191 - if (!e->processed

1192 - && !process_entry(path, e, branch1, branch2))

1193 - clean = 0;

1194 - }

1195 -

1196 - string_list_clear(re_merge, 0);

1197 - string_list_clear(re_head, 0);

1198 - string_list_clear(entries, 1);

1199 -

1200 - }

1201 - else

1202 - clean = 1;

1203 -

1204 - if (index_only)

1205 - *result = write_tree_from_memory();

1206 -

1207 - return clean;

1208 -}

1209 -

1210 -static struct commit_list *reverse_commit_list(struct commit_list *list)

1211 -{

1212 - struct commit_list *next = NULL, *current, *backup;

1213 - for (current = list; current; current = backup) {

1214 - backup = current->next;

1215 - current->next = next;

1216 - next = current;

1217 - }

1218 - return next;

1219 -}

1220 -

1221 -/*

1222 - * Merge the commits h1 and h2, return the resulting virtual

1223 - * commit object and a flag indicating the cleanness of the merge.

1224 - */

1225 -int merge_recursive(struct commit *h1,

1226 - struct commit *h2,

1227 - const char *branch1,

1228 - const char *branch2,

1229 - struct commit_list *ca,

1230 - struct commit **result)

1231 -{

1232 - struct commit_list *iter;

1233 - struct commit *merged_common_ancestors;

1234 - struct tree *mrtree = mrtree;

1235 - int clean;

1236 -

1237 - if (show(4)) {

1238 - output(4, "Merging:");

1239 - output_commit_title(h1);

1240 - output_commit_title(h2);

1241 - }

1242 -

1243 - if (!ca) {

1244 - ca = get_merge_bases(h1, h2, 1);

1245 - ca = reverse_commit_list(ca);

1246 - }

1247 -

1248 - if (show(5)) {

1249 - output(5, "found %u common ancestor(s):", commit_list_count(ca));

1250 - for (iter = ca; iter; iter = iter->next)

1251 - output_commit_title(iter->item);

1252 - }

1253 -

1254 - merged_common_ancestors = pop_commit(&ca);

1255 - if (merged_common_ancestors == NULL) {

1256 - /* if there is no common ancestor, make an empty tree */

1257 - struct tree *tree = xcalloc(1, sizeof(struct tree));

1258 -

1259 - tree->object.parsed = 1;

1260 - tree->object.type = OBJ_TREE;

1261 - pretend_sha1_file(NULL, 0, OBJ_TREE, tree->object.sha1);

1262 - merged_common_ancestors = make_virtual_commit(tree, "ancestor");

1263 - }

1264 -

1265 - for (iter = ca; iter; iter = iter->next) {

1266 - call_depth++;

1267 - /*

1268 - * When the merge fails, the result contains files

1269 - * with conflict markers. The cleanness flag is

1270 - * ignored, it was never actually used, as result of

1271 - * merge_trees has always overwritten it: the committed

1272 - * "conflicts" were already resolved.

1273 - */

1274 - discard_cache();

1275 - merge_recursive(merged_common_ancestors, iter->item,

1276 - "Temporary merge branch 1",

1277 - "Temporary merge branch 2",

1278 - NULL,

1279 - &merged_common_ancestors);

1280 - call_depth--;

1281 -

1282 - if (!merged_common_ancestors)

1283 - die("merge returned no commit");

1284 - }

1285 -

1286 - discard_cache();

1287 - if (!call_depth) {

1288 - read_cache();

1289 - index_only = 0;

1290 - } else

1291 - index_only = 1;

1292 -

1293 - clean = merge_trees(h1->tree, h2->tree, merged_common_ancestors->tree,

1294 - branch1, branch2, &mrtree);

1295 -

1296 - if (index_only) {

1297 - *result = make_virtual_commit(mrtree, "merged tree");

1298 - commit_list_insert(h1, &(*result)->parents);

1299 - commit_list_insert(h2, &(*result)->parents->next);

1300 - }

1301 - flush_output();

1302 - return clean;

1303 -}

1304 -

6 static const char *better_branch_name(const char *branch)

7 {

8 static char githead_env[8 + 40 + 1];

@@ -1334,23 +35,6 @@ static struct commit *get_ref(const char *ref)

35 return (struct commit *)object;

36 }

1337 -static int merge_config(const char *var, const char *value, void *cb)

1338 -{

1339 - if (!strcasecmp(var, "merge.verbosity")) {

1340 - verbosity = git_config_int(var, value);

1341 - return 0;

1342 - }

1343 - if (!strcasecmp(var, "diff.renamelimit")) {

1344 - diff_rename_limit = git_config_int(var, value);

1345 - return 0;

1346 - }

1347 - if (!strcasecmp(var, "merge.renamelimit")) {

1348 - merge_rename_limit = git_config_int(var, value);

1349 - return 0;

1350 - }

1351 - return git_default_config(var, value, cb);

1352 -}

1353 -

38 int cmd_merge_recursive(int argc, const char **argv, const char *prefix)

39 {

40 static const char *bases[20];

@@ -1361,6 +45,7 @@ int cmd_merge_recursive(int argc, const char **argv, const char *prefix)

45 struct commit_list *ca = NULL;

46 struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));

47 int index_fd;

48 + int subtree_merge = 0;

50 if (argv[0]) {

51 int namelen = strlen(argv[0]);

@@ -1369,10 +54,8 @@ int cmd_merge_recursive(int argc, const char **argv, const char *prefix)

54 subtree_merge = 1;

55 }

1372 - git_config(merge_config, NULL);

1373 - if (getenv("GIT_MERGE_VERBOSITY"))

1374 - verbosity = strtol(getenv("GIT_MERGE_VERBOSITY"), NULL, 10);

1375 -

57 + git_config(merge_recursive_config, NULL);

58 + merge_recursive_setup(subtree_merge);

59 if (argc < 4)

60 die("Usage: %s <base>... -- <head> <remote> ...\n", argv[0]);

@@ -1384,8 +67,6 @@ int cmd_merge_recursive(int argc, const char **argv, const char *prefix)

67 }

68 if (argc - i != 3) /* "--" "<head>" "<remote>" */

69 die("Not handling anything other than two heads merge.");

1387 - if (verbosity >= 5)

1388 - buffer_output = 0;

71 branch1 = argv[++i];

72 branch2 = argv[++i];

@@ -1396,7 +77,7 @@ int cmd_merge_recursive(int argc, const char **argv, const char *prefix)

77 branch1 = better_branch_name(branch1);

78 branch2 = better_branch_name(branch2);

1399 - if (show(3))

80 + if (merge_recursive_verbosity >= 3)

81 printf("Merging %s with %s\n", branch1, branch2);

83 index_fd = hold_locked_index(lock, 1);

merge-recursive.c new

+1331

@@ -0,0 +1,1331 @@

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 "cache-tree.h"

8 +#include "commit.h"

9 +#include "blob.h"

10 +#include "builtin.h"

11 +#include "tree-walk.h"

12 +#include "diff.h"

13 +#include "diffcore.h"

14 +#include "tag.h"

15 +#include "unpack-trees.h"

16 +#include "string-list.h"

17 +#include "xdiff-interface.h"

18 +#include "ll-merge.h"

19 +#include "interpolate.h"

20 +#include "attr.h"

21 +#include "merge-recursive.h"

22 +

23 +static int subtree_merge;

24 +

25 +static struct tree *shift_tree_object(struct tree *one, struct tree *two)

26 +{

27 + unsigned char shifted[20];

28 +

29 + /*

30 + * NEEDSWORK: this limits the recursion depth to hardcoded

31 + * value '2' to avoid excessive overhead.

32 + */

33 + shift_tree(one->object.sha1, two->object.sha1, shifted, 2);

34 + if (!hashcmp(two->object.sha1, shifted))

35 + return two;

36 + return lookup_tree(shifted);

37 +}

38 +

39 +/*

40 + * A virtual commit has

41 + * - (const char *)commit->util set to the name, and

42 + * - *(int *)commit->object.sha1 set to the virtual id.

43 + */

44 +

45 +struct commit *make_virtual_commit(struct tree *tree, const char *comment)

46 +{

47 + struct commit *commit = xcalloc(1, sizeof(struct commit));

48 + static unsigned virtual_id = 1;

49 + commit->tree = tree;

50 + commit->util = (void*)comment;

51 + *(int*)commit->object.sha1 = virtual_id++;

52 + /* avoid warnings */

53 + commit->object.parsed = 1;

54 + return commit;

55 +}

56 +

57 +/*

58 + * Since we use get_tree_entry(), which does not put the read object into

59 + * the object pool, we cannot rely on a == b.

60 + */

61 +static int sha_eq(const unsigned char *a, const unsigned char *b)

62 +{

63 + if (!a && !b)

64 + return 2;

65 + return a && b && hashcmp(a, b) == 0;

66 +}

67 +

68 +/*

69 + * Since we want to write the index eventually, we cannot reuse the index

70 + * for these (temporary) data.

71 + */

72 +struct stage_data

73 +{

74 + struct

75 + {

76 + unsigned mode;

77 + unsigned char sha[20];

78 + } stages[4];

79 + unsigned processed:1;

80 +};

81 +

82 +static struct string_list current_file_set = {NULL, 0, 0, 1};

83 +static struct string_list current_directory_set = {NULL, 0, 0, 1};

84 +

85 +static int call_depth = 0;

86 +int merge_recursive_verbosity = 2;

87 +static int diff_rename_limit = -1;

88 +static int merge_rename_limit = -1;

89 +static int buffer_output = 1;

90 +static struct strbuf obuf = STRBUF_INIT;

91 +

92 +static int show(int v)

93 +{

94 + return (!call_depth && merge_recursive_verbosity >= v) ||

95 + merge_recursive_verbosity >= 5;

96 +}

97 +

98 +static void flush_output(void)

99 +{

100 + if (obuf.len) {

101 + fputs(obuf.buf, stdout);

102 + strbuf_reset(&obuf);

103 + }

104 +}

105 +

106 +static void output(int v, const char *fmt, ...)

107 +{

108 + int len;

109 + va_list ap;

110 +

111 + if (!show(v))

112 + return;

113 +

114 + strbuf_grow(&obuf, call_depth * 2 + 2);

115 + memset(obuf.buf + obuf.len, ' ', call_depth * 2);

116 + strbuf_setlen(&obuf, obuf.len + call_depth * 2);

117 +

118 + va_start(ap, fmt);

119 + len = vsnprintf(obuf.buf + obuf.len, strbuf_avail(&obuf), fmt, ap);

120 + va_end(ap);

121 +

122 + if (len < 0)

123 + len = 0;

124 + if (len >= strbuf_avail(&obuf)) {

125 + strbuf_grow(&obuf, len + 2);

126 + va_start(ap, fmt);

127 + len = vsnprintf(obuf.buf + obuf.len, strbuf_avail(&obuf), fmt, ap);

128 + va_end(ap);

129 + if (len >= strbuf_avail(&obuf)) {

130 + die("this should not happen, your snprintf is broken");

131 + }

132 + }

133 + strbuf_setlen(&obuf, obuf.len + len);

134 + strbuf_add(&obuf, "\n", 1);

135 + if (!buffer_output)

136 + flush_output();

137 +}

138 +

139 +static void output_commit_title(struct commit *commit)

140 +{

141 + int i;

142 + flush_output();

143 + for (i = call_depth; i--;)

144 + fputs(" ", stdout);

145 + if (commit->util)

146 + printf("virtual %s\n", (char *)commit->util);

147 + else {

148 + printf("%s ", find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV));

149 + if (parse_commit(commit) != 0)

150 + printf("(bad commit)\n");

151 + else {

152 + const char *s;

153 + int len;

154 + for (s = commit->buffer; *s; s++)

155 + if (*s == '\n' && s[1] == '\n') {

156 + s += 2;

157 + break;

158 + }

159 + for (len = 0; s[len] && '\n' != s[len]; len++)

160 + ; /* do nothing */

161 + printf("%.*s\n", len, s);

162 + }

163 + }

164 +}

165 +

166 +static int add_cacheinfo(unsigned int mode, const unsigned char *sha1,

167 + const char *path, int stage, int refresh, int options)

168 +{

169 + struct cache_entry *ce;

170 + ce = make_cache_entry(mode, sha1 ? sha1 : null_sha1, path, stage, refresh);

171 + if (!ce)

172 + return error("addinfo_cache failed for path '%s'", path);

173 + return add_cache_entry(ce, options);

174 +}

175 +

176 +/*

177 + * This is a global variable which is used in a number of places but

178 + * only written to in the 'merge' function.

179 + *

180 + * index_only == 1 => Don't leave any non-stage 0 entries in the cache and

181 + * don't update the working directory.

182 + * 0 => Leave unmerged entries in the cache and update

183 + * the working directory.

184 + */

185 +static int index_only = 0;

186 +

187 +static void init_tree_desc_from_tree(struct tree_desc *desc, struct tree *tree)

188 +{

189 + parse_tree(tree);

190 + init_tree_desc(desc, tree->buffer, tree->size);

191 +}

192 +

193 +static int git_merge_trees(int index_only,

194 + struct tree *common,

195 + struct tree *head,

196 + struct tree *merge)

197 +{

198 + int rc;

199 + struct tree_desc t[3];

200 + struct unpack_trees_options opts;

201 +

202 + memset(&opts, 0, sizeof(opts));

203 + if (index_only)

204 + opts.index_only = 1;

205 + else

206 + opts.update = 1;

207 + opts.merge = 1;

208 + opts.head_idx = 2;

209 + opts.fn = threeway_merge;

210 + opts.src_index = &the_index;

211 + opts.dst_index = &the_index;

212 +

213 + init_tree_desc_from_tree(t+0, common);

214 + init_tree_desc_from_tree(t+1, head);

215 + init_tree_desc_from_tree(t+2, merge);

216 +

217 + rc = unpack_trees(3, t, &opts);

218 + cache_tree_free(&active_cache_tree);

219 + return rc;

220 +}

221 +

222 +struct tree *write_tree_from_memory(void)

223 +{

224 + struct tree *result = NULL;

225 +

226 + if (unmerged_cache()) {

227 + int i;

228 + output(0, "There are unmerged index entries:");

229 + for (i = 0; i < active_nr; i++) {

230 + struct cache_entry *ce = active_cache[i];

231 + if (ce_stage(ce))

232 + output(0, "%d %.*s", ce_stage(ce), ce_namelen(ce), ce->name);

233 + }

234 + return NULL;

235 + }

236 +

237 + if (!active_cache_tree)

238 + active_cache_tree = cache_tree();

239 +

240 + if (!cache_tree_fully_valid(active_cache_tree) &&

241 + cache_tree_update(active_cache_tree,

242 + active_cache, active_nr, 0, 0) < 0)

243 + die("error building trees");

244 +

245 + result = lookup_tree(active_cache_tree->sha1);

246 +

247 + return result;

248 +}

249 +

250 +static int save_files_dirs(const unsigned char *sha1,

251 + const char *base, int baselen, const char *path,

252 + unsigned int mode, int stage, void *context)

253 +{

254 + int len = strlen(path);

255 + char *newpath = xmalloc(baselen + len + 1);

256 + memcpy(newpath, base, baselen);

257 + memcpy(newpath + baselen, path, len);

258 + newpath[baselen + len] = '\0';

259 +

260 + if (S_ISDIR(mode))

261 + string_list_insert(newpath, &current_directory_set);

262 + else

263 + string_list_insert(newpath, &current_file_set);

264 + free(newpath);

265 +

266 + return READ_TREE_RECURSIVE;

267 +}

268 +

269 +static int get_files_dirs(struct tree *tree)

270 +{

271 + int n;

272 + if (read_tree_recursive(tree, "", 0, 0, NULL, save_files_dirs, NULL))

273 + return 0;

274 + n = current_file_set.nr + current_directory_set.nr;

275 + return n;

276 +}

277 +

278 +/*

279 + * Returns an index_entry instance which doesn't have to correspond to

280 + * a real cache entry in Git's index.

281 + */

282 +static struct stage_data *insert_stage_data(const char *path,

283 + struct tree *o, struct tree *a, struct tree *b,

284 + struct string_list *entries)

285 +{

286 + struct string_list_item *item;

287 + struct stage_data *e = xcalloc(1, sizeof(struct stage_data));

288 + get_tree_entry(o->object.sha1, path,

289 + e->stages[1].sha, &e->stages[1].mode);

290 + get_tree_entry(a->object.sha1, path,

291 + e->stages[2].sha, &e->stages[2].mode);

292 + get_tree_entry(b->object.sha1, path,

293 + e->stages[3].sha, &e->stages[3].mode);

294 + item = string_list_insert(path, entries);

295 + item->util = e;

296 + return e;

297 +}

298 +

299 +/*

300 + * Create a dictionary mapping file names to stage_data objects. The

301 + * dictionary contains one entry for every path with a non-zero stage entry.

302 + */

303 +static struct string_list *get_unmerged(void)

304 +{

305 + struct string_list *unmerged = xcalloc(1, sizeof(struct string_list));

306 + int i;

307 +

308 + unmerged->strdup_strings = 1;

309 +

310 + for (i = 0; i < active_nr; i++) {

311 + struct string_list_item *item;

312 + struct stage_data *e;

313 + struct cache_entry *ce = active_cache[i];

314 + if (!ce_stage(ce))

315 + continue;

316 +

317 + item = string_list_lookup(ce->name, unmerged);

318 + if (!item) {

319 + item = string_list_insert(ce->name, unmerged);

320 + item->util = xcalloc(1, sizeof(struct stage_data));

321 + }

322 + e = item->util;

323 + e->stages[ce_stage(ce)].mode = ce->ce_mode;

324 + hashcpy(e->stages[ce_stage(ce)].sha, ce->sha1);

325 + }

326 +

327 + return unmerged;

328 +}

329 +

330 +struct rename

331 +{

332 + struct diff_filepair *pair;

333 + struct stage_data *src_entry;

334 + struct stage_data *dst_entry;

335 + unsigned processed:1;

336 +};

337 +

338 +/*

339 + * Get information of all renames which occurred between 'o_tree' and

340 + * 'tree'. We need the three trees in the merge ('o_tree', 'a_tree' and

341 + * 'b_tree') to be able to associate the correct cache entries with

342 + * the rename information. 'tree' is always equal to either a_tree or b_tree.

343 + */

344 +static struct string_list *get_renames(struct tree *tree,

345 + struct tree *o_tree,

346 + struct tree *a_tree,

347 + struct tree *b_tree,

348 + struct string_list *entries)

349 +{

350 + int i;

351 + struct string_list *renames;

352 + struct diff_options opts;

353 +

354 + renames = xcalloc(1, sizeof(struct string_list));

355 + diff_setup(&opts);

356 + DIFF_OPT_SET(&opts, RECURSIVE);

357 + opts.detect_rename = DIFF_DETECT_RENAME;

358 + opts.rename_limit = merge_rename_limit >= 0 ? merge_rename_limit :

359 + diff_rename_limit >= 0 ? diff_rename_limit :

360 + 500;

361 + opts.warn_on_too_large_rename = 1;

362 + opts.output_format = DIFF_FORMAT_NO_OUTPUT;

363 + if (diff_setup_done(&opts) < 0)

364 + die("diff setup failed");

365 + diff_tree_sha1(o_tree->object.sha1, tree->object.sha1, "", &opts);

366 + diffcore_std(&opts);

367 + for (i = 0; i < diff_queued_diff.nr; ++i) {

368 + struct string_list_item *item;

369 + struct rename *re;

370 + struct diff_filepair *pair = diff_queued_diff.queue[i];

371 + if (pair->status != 'R') {

372 + diff_free_filepair(pair);

373 + continue;

374 + }

375 + re = xmalloc(sizeof(*re));

376 + re->processed = 0;

377 + re->pair = pair;

378 + item = string_list_lookup(re->pair->one->path, entries);

379 + if (!item)

380 + re->src_entry = insert_stage_data(re->pair->one->path,

381 + o_tree, a_tree, b_tree, entries);

382 + else

383 + re->src_entry = item->util;

384 +

385 + item = string_list_lookup(re->pair->two->path, entries);

386 + if (!item)

387 + re->dst_entry = insert_stage_data(re->pair->two->path,

388 + o_tree, a_tree, b_tree, entries);

389 + else

390 + re->dst_entry = item->util;

391 + item = string_list_insert(pair->one->path, renames);

392 + item->util = re;

393 + }

394 + opts.output_format = DIFF_FORMAT_NO_OUTPUT;

395 + diff_queued_diff.nr = 0;

396 + diff_flush(&opts);

397 + return renames;

398 +}

399 +

400 +static int update_stages(const char *path, struct diff_filespec *o,

401 + struct diff_filespec *a, struct diff_filespec *b,

402 + int clear)

403 +{

404 + int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE;

405 + if (clear)

406 + if (remove_file_from_cache(path))

407 + return -1;

408 + if (o)

409 + if (add_cacheinfo(o->mode, o->sha1, path, 1, 0, options))

410 + return -1;

411 + if (a)

412 + if (add_cacheinfo(a->mode, a->sha1, path, 2, 0, options))

413 + return -1;

414 + if (b)

415 + if (add_cacheinfo(b->mode, b->sha1, path, 3, 0, options))

416 + return -1;

417 + return 0;

418 +}

419 +

420 +static int remove_path(const char *name)

421 +{

422 + int ret;

423 + char *slash, *dirs;

424 +

425 + ret = unlink(name);

426 + if (ret)

427 + return ret;

428 + dirs = xstrdup(name);

429 + while ((slash = strrchr(name, '/'))) {

430 + *slash = '\0';

431 + if (rmdir(name) != 0)

432 + break;

433 + }

434 + free(dirs);

435 + return ret;

436 +}

437 +

438 +static int remove_file(int clean, const char *path, int no_wd)

439 +{

440 + int update_cache = index_only || clean;

441 + int update_working_directory = !index_only && !no_wd;

442 +

443 + if (update_cache) {

444 + if (remove_file_from_cache(path))

445 + return -1;

446 + }

447 + if (update_working_directory) {

448 + unlink(path);

449 + if (errno != ENOENT || errno != EISDIR)

450 + return -1;

451 + remove_path(path);

452 + }

453 + return 0;

454 +}

455 +

456 +static char *unique_path(const char *path, const char *branch)

457 +{

458 + char *newpath = xmalloc(strlen(path) + 1 + strlen(branch) + 8 + 1);

459 + int suffix = 0;

460 + struct stat st;

461 + char *p = newpath + strlen(path);

462 + strcpy(newpath, path);

463 + *(p++) = '~';

464 + strcpy(p, branch);

465 + for (; *p; ++p)

466 + if ('/' == *p)

467 + *p = '_';

468 + while (string_list_has_string(&current_file_set, newpath) ||

469 + string_list_has_string(&current_directory_set, newpath) ||

470 + lstat(newpath, &st) == 0)

471 + sprintf(p, "_%d", suffix++);

472 +

473 + string_list_insert(newpath, &current_file_set);

474 + return newpath;

475 +}

476 +

477 +static void flush_buffer(int fd, const char *buf, unsigned long size)

478 +{

479 + while (size > 0) {

480 + long ret = write_in_full(fd, buf, size);

481 + if (ret < 0) {

482 + /* Ignore epipe */

483 + if (errno == EPIPE)

484 + break;

485 + die("merge-recursive: %s", strerror(errno));

486 + } else if (!ret) {

487 + die("merge-recursive: disk full?");

488 + }

489 + size -= ret;

490 + buf += ret;

491 + }

492 +}

493 +

494 +static int make_room_for_path(const char *path)

495 +{

496 + int status;

497 + const char *msg = "failed to create path '%s'%s";

498 +

499 + status = safe_create_leading_directories_const(path);

500 + if (status) {

501 + if (status == -3) {

502 + /* something else exists */

503 + error(msg, path, ": perhaps a D/F conflict?");

504 + return -1;

505 + }

506 + die(msg, path, "");

507 + }

508 +

509 + /* Successful unlink is good.. */

510 + if (!unlink(path))

511 + return 0;

512 + /* .. and so is no existing file */

513 + if (errno == ENOENT)

514 + return 0;

515 + /* .. but not some other error (who really cares what?) */

516 + return error(msg, path, ": perhaps a D/F conflict?");

517 +}

518 +

519 +static void update_file_flags(const unsigned char *sha,

520 + unsigned mode,

521 + const char *path,

522 + int update_cache,

523 + int update_wd)

524 +{

525 + if (index_only)

526 + update_wd = 0;

527 +

528 + if (update_wd) {

529 + enum object_type type;

530 + void *buf;

531 + unsigned long size;

532 +

533 + if (S_ISGITLINK(mode))

534 + die("cannot read object %s '%s': It is a submodule!",

535 + sha1_to_hex(sha), path);

536 +

537 + buf = read_sha1_file(sha, &type, &size);

538 + if (!buf)

539 + die("cannot read object %s '%s'", sha1_to_hex(sha), path);

540 + if (type != OBJ_BLOB)

541 + die("blob expected for %s '%s'", sha1_to_hex(sha), path);

542 + if (S_ISREG(mode)) {

543 + struct strbuf strbuf;

544 + strbuf_init(&strbuf, 0);

545 + if (convert_to_working_tree(path, buf, size, &strbuf)) {

546 + free(buf);

547 + size = strbuf.len;

548 + buf = strbuf_detach(&strbuf, NULL);

549 + }

550 + }

551 +

552 + if (make_room_for_path(path) < 0) {

553 + update_wd = 0;

554 + free(buf);

555 + goto update_index;

556 + }

557 + if (S_ISREG(mode) || (!has_symlinks && S_ISLNK(mode))) {

558 + int fd;

559 + if (mode & 0100)

560 + mode = 0777;

561 + else

562 + mode = 0666;

563 + fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);

564 + if (fd < 0)

565 + die("failed to open %s: %s", path, strerror(errno));

566 + flush_buffer(fd, buf, size);

567 + close(fd);

568 + } else if (S_ISLNK(mode)) {

569 + char *lnk = xmemdupz(buf, size);

570 + safe_create_leading_directories_const(path);

571 + unlink(path);

572 + symlink(lnk, path);

573 + free(lnk);

574 + } else

575 + die("do not know what to do with %06o %s '%s'",

576 + mode, sha1_to_hex(sha), path);

577 + free(buf);

578 + }

579 + update_index:

580 + if (update_cache)

581 + add_cacheinfo(mode, sha, path, 0, update_wd, ADD_CACHE_OK_TO_ADD);

582 +}

583 +

584 +static void update_file(int clean,

585 + const unsigned char *sha,

586 + unsigned mode,

587 + const char *path)

588 +{

589 + update_file_flags(sha, mode, path, index_only || clean, !index_only);

590 +}

591 +

592 +/* Low level file merging, update and removal */

593 +

594 +struct merge_file_info

595 +{

596 + unsigned char sha[20];

597 + unsigned mode;

598 + unsigned clean:1,

599 + merge:1;

600 +};

601 +

602 +static void fill_mm(const unsigned char *sha1, mmfile_t *mm)

603 +{

604 + unsigned long size;

605 + enum object_type type;

606 +

607 + if (!hashcmp(sha1, null_sha1)) {

608 + mm->ptr = xstrdup("");

609 + mm->size = 0;

610 + return;

611 + }

612 +

613 + mm->ptr = read_sha1_file(sha1, &type, &size);

614 + if (!mm->ptr || type != OBJ_BLOB)

615 + die("unable to read blob object %s", sha1_to_hex(sha1));

616 + mm->size = size;

617 +}

618 +

619 +static int merge_3way(mmbuffer_t *result_buf,

620 + struct diff_filespec *o,

621 + struct diff_filespec *a,

622 + struct diff_filespec *b,

623 + const char *branch1,

624 + const char *branch2)

625 +{

626 + mmfile_t orig, src1, src2;

627 + char *name1, *name2;

628 + int merge_status;

629 +

630 + name1 = xstrdup(mkpath("%s:%s", branch1, a->path));

631 + name2 = xstrdup(mkpath("%s:%s", branch2, b->path));

632 +

633 + fill_mm(o->sha1, &orig);

634 + fill_mm(a->sha1, &src1);

635 + fill_mm(b->sha1, &src2);

636 +

637 + merge_status = ll_merge(result_buf, a->path, &orig,

638 + &src1, name1, &src2, name2,

639 + index_only);

640 +

641 + free(name1);

642 + free(name2);

643 + free(orig.ptr);

644 + free(src1.ptr);

645 + free(src2.ptr);

646 + return merge_status;

647 +}

648 +

649 +static struct merge_file_info merge_file(struct diff_filespec *o,

650 + struct diff_filespec *a, struct diff_filespec *b,

651 + const char *branch1, const char *branch2)

652 +{

653 + struct merge_file_info result;

654 + result.merge = 0;

655 + result.clean = 1;

656 +

657 + if ((S_IFMT & a->mode) != (S_IFMT & b->mode)) {

658 + result.clean = 0;

659 + if (S_ISREG(a->mode)) {

660 + result.mode = a->mode;

661 + hashcpy(result.sha, a->sha1);

662 + } else {

663 + result.mode = b->mode;

664 + hashcpy(result.sha, b->sha1);

665 + }

666 + } else {

667 + if (!sha_eq(a->sha1, o->sha1) && !sha_eq(b->sha1, o->sha1))

668 + result.merge = 1;

669 +

670 + /*

671 + * Merge modes

672 + */

673 + if (a->mode == b->mode || a->mode == o->mode)

674 + result.mode = b->mode;

675 + else {

676 + result.mode = a->mode;

677 + if (b->mode != o->mode) {

678 + result.clean = 0;

679 + result.merge = 1;

680 + }

681 + }

682 +

683 + if (sha_eq(a->sha1, b->sha1) || sha_eq(a->sha1, o->sha1))

684 + hashcpy(result.sha, b->sha1);

685 + else if (sha_eq(b->sha1, o->sha1))

686 + hashcpy(result.sha, a->sha1);

687 + else if (S_ISREG(a->mode)) {

688 + mmbuffer_t result_buf;

689 + int merge_status;

690 +

691 + merge_status = merge_3way(&result_buf, o, a, b,

692 + branch1, branch2);

693 +

694 + if ((merge_status < 0) || !result_buf.ptr)

695 + die("Failed to execute internal merge");

696 +

697 + if (write_sha1_file(result_buf.ptr, result_buf.size,

698 + blob_type, result.sha))

699 + die("Unable to add %s to database",

700 + a->path);

701 +

702 + free(result_buf.ptr);

703 + result.clean = (merge_status == 0);

704 + } else if (S_ISGITLINK(a->mode)) {

705 + result.clean = 0;

706 + hashcpy(result.sha, a->sha1);

707 + } else if (S_ISLNK(a->mode)) {

708 + hashcpy(result.sha, a->sha1);

709 +

710 + if (!sha_eq(a->sha1, b->sha1))

711 + result.clean = 0;

712 + } else {

713 + die("unsupported object type in the tree");

714 + }

715 + }

716 +

717 + return result;

718 +}

719 +

720 +static void conflict_rename_rename(struct rename *ren1,

721 + const char *branch1,

722 + struct rename *ren2,

723 + const char *branch2)

724 +{

725 + char *del[2];

726 + int delp = 0;

727 + const char *ren1_dst = ren1->pair->two->path;

728 + const char *ren2_dst = ren2->pair->two->path;

729 + const char *dst_name1 = ren1_dst;

730 + const char *dst_name2 = ren2_dst;

731 + if (string_list_has_string(&current_directory_set, ren1_dst)) {

732 + dst_name1 = del[delp++] = unique_path(ren1_dst, branch1);

733 + output(1, "%s is a directory in %s adding as %s instead",

734 + ren1_dst, branch2, dst_name1);

735 + remove_file(0, ren1_dst, 0);

736 + }

737 + if (string_list_has_string(&current_directory_set, ren2_dst)) {

738 + dst_name2 = del[delp++] = unique_path(ren2_dst, branch2);

739 + output(1, "%s is a directory in %s adding as %s instead",

740 + ren2_dst, branch1, dst_name2);

741 + remove_file(0, ren2_dst, 0);

742 + }

743 + if (index_only) {

744 + remove_file_from_cache(dst_name1);

745 + remove_file_from_cache(dst_name2);

746 + /*

747 + * Uncomment to leave the conflicting names in the resulting tree

748 + *

749 + * update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, dst_name1);

750 + * update_file(0, ren2->pair->two->sha1, ren2->pair->two->mode, dst_name2);

751 + */

752 + } else {

753 + update_stages(dst_name1, NULL, ren1->pair->two, NULL, 1);

754 + update_stages(dst_name2, NULL, NULL, ren2->pair->two, 1);

755 + }

756 + while (delp--)

757 + free(del[delp]);

758 +}

759 +

760 +static void conflict_rename_dir(struct rename *ren1,

761 + const char *branch1)

762 +{

763 + char *new_path = unique_path(ren1->pair->two->path, branch1);

764 + output(1, "Renaming %s to %s instead", ren1->pair->one->path, new_path);

765 + remove_file(0, ren1->pair->two->path, 0);

766 + update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, new_path);

767 + free(new_path);

768 +}

769 +

770 +static void conflict_rename_rename_2(struct rename *ren1,

771 + const char *branch1,

772 + struct rename *ren2,

773 + const char *branch2)

774 +{

775 + char *new_path1 = unique_path(ren1->pair->two->path, branch1);

776 + char *new_path2 = unique_path(ren2->pair->two->path, branch2);

777 + output(1, "Renaming %s to %s and %s to %s instead",

778 + ren1->pair->one->path, new_path1,

779 + ren2->pair->one->path, new_path2);

780 + remove_file(0, ren1->pair->two->path, 0);

781 + update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, new_path1);

782 + update_file(0, ren2->pair->two->sha1, ren2->pair->two->mode, new_path2);

783 + free(new_path2);

784 + free(new_path1);

785 +}

786 +

787 +static int process_renames(struct string_list *a_renames,

788 + struct string_list *b_renames,

789 + const char *a_branch,

790 + const char *b_branch)

791 +{

792 + int clean_merge = 1, i, j;

793 + struct string_list a_by_dst = {NULL, 0, 0, 0}, b_by_dst = {NULL, 0, 0, 0};

794 + const struct rename *sre;

795 +

796 + for (i = 0; i < a_renames->nr; i++) {

797 + sre = a_renames->items[i].util;

798 + string_list_insert(sre->pair->two->path, &a_by_dst)->util

799 + = sre->dst_entry;

800 + }

801 + for (i = 0; i < b_renames->nr; i++) {

802 + sre = b_renames->items[i].util;

803 + string_list_insert(sre->pair->two->path, &b_by_dst)->util

804 + = sre->dst_entry;

805 + }

806 +

807 + for (i = 0, j = 0; i < a_renames->nr || j < b_renames->nr;) {

808 + int compare;

809 + char *src;

810 + struct string_list *renames1, *renames2, *renames2Dst;

811 + struct rename *ren1 = NULL, *ren2 = NULL;

812 + const char *branch1, *branch2;

813 + const char *ren1_src, *ren1_dst;

814 +

815 + if (i >= a_renames->nr) {

816 + compare = 1;

817 + ren2 = b_renames->items[j++].util;

818 + } else if (j >= b_renames->nr) {

819 + compare = -1;

820 + ren1 = a_renames->items[i++].util;

821 + } else {

822 + compare = strcmp(a_renames->items[i].string,

823 + b_renames->items[j].string);

824 + if (compare <= 0)

825 + ren1 = a_renames->items[i++].util;

826 + if (compare >= 0)

827 + ren2 = b_renames->items[j++].util;

828 + }

829 +

830 + /* TODO: refactor, so that 1/2 are not needed */

831 + if (ren1) {

832 + renames1 = a_renames;

833 + renames2 = b_renames;

834 + renames2Dst = &b_by_dst;

835 + branch1 = a_branch;

836 + branch2 = b_branch;

837 + } else {

838 + struct rename *tmp;

839 + renames1 = b_renames;

840 + renames2 = a_renames;

841 + renames2Dst = &a_by_dst;

842 + branch1 = b_branch;

843 + branch2 = a_branch;

844 + tmp = ren2;

845 + ren2 = ren1;

846 + ren1 = tmp;

847 + }

848 + src = ren1->pair->one->path;

849 +

850 + ren1->dst_entry->processed = 1;

851 + ren1->src_entry->processed = 1;

852 +

853 + if (ren1->processed)

854 + continue;

855 + ren1->processed = 1;

856 +

857 + ren1_src = ren1->pair->one->path;

858 + ren1_dst = ren1->pair->two->path;

859 +

860 + if (ren2) {

861 + const char *ren2_src = ren2->pair->one->path;

862 + const char *ren2_dst = ren2->pair->two->path;

863 + /* Renamed in 1 and renamed in 2 */

864 + if (strcmp(ren1_src, ren2_src) != 0)

865 + die("ren1.src != ren2.src");

866 + ren2->dst_entry->processed = 1;

867 + ren2->processed = 1;

868 + if (strcmp(ren1_dst, ren2_dst) != 0) {

869 + clean_merge = 0;

870 + output(1, "CONFLICT (rename/rename): "

871 + "Rename \"%s\"->\"%s\" in branch \"%s\" "

872 + "rename \"%s\"->\"%s\" in \"%s\"%s",

873 + src, ren1_dst, branch1,

874 + src, ren2_dst, branch2,

875 + index_only ? " (left unresolved)": "");

876 + if (index_only) {

877 + remove_file_from_cache(src);

878 + update_file(0, ren1->pair->one->sha1,

879 + ren1->pair->one->mode, src);

880 + }

881 + conflict_rename_rename(ren1, branch1, ren2, branch2);

882 + } else {

883 + struct merge_file_info mfi;

884 + remove_file(1, ren1_src, 1);

885 + mfi = merge_file(ren1->pair->one,

886 + ren1->pair->two,

887 + ren2->pair->two,

888 + branch1,

889 + branch2);

890 + if (mfi.merge || !mfi.clean)

891 + output(1, "Renaming %s->%s", src, ren1_dst);

892 +

893 + if (mfi.merge)

894 + output(2, "Auto-merging %s", ren1_dst);

895 +

896 + if (!mfi.clean) {

897 + output(1, "CONFLICT (content): merge conflict in %s",

898 + ren1_dst);

899 + clean_merge = 0;

900 +

901 + if (!index_only)

902 + update_stages(ren1_dst,

903 + ren1->pair->one,

904 + ren1->pair->two,

905 + ren2->pair->two,

906 + 1 /* clear */);

907 + }

908 + update_file(mfi.clean, mfi.sha, mfi.mode, ren1_dst);

909 + }

910 + } else {

911 + /* Renamed in 1, maybe changed in 2 */

912 + struct string_list_item *item;

913 + /* we only use sha1 and mode of these */

914 + struct diff_filespec src_other, dst_other;

915 + int try_merge, stage = a_renames == renames1 ? 3: 2;

916 +

917 + remove_file(1, ren1_src, index_only || stage == 3);

918 +

919 + hashcpy(src_other.sha1, ren1->src_entry->stages[stage].sha);

920 + src_other.mode = ren1->src_entry->stages[stage].mode;

921 + hashcpy(dst_other.sha1, ren1->dst_entry->stages[stage].sha);

922 + dst_other.mode = ren1->dst_entry->stages[stage].mode;

923 +

924 + try_merge = 0;

925 +

926 + if (string_list_has_string(&current_directory_set, ren1_dst)) {

927 + clean_merge = 0;

928 + output(1, "CONFLICT (rename/directory): Rename %s->%s in %s "

929 + " directory %s added in %s",

930 + ren1_src, ren1_dst, branch1,

931 + ren1_dst, branch2);

932 + conflict_rename_dir(ren1, branch1);

933 + } else if (sha_eq(src_other.sha1, null_sha1)) {

934 + clean_merge = 0;

935 + output(1, "CONFLICT (rename/delete): Rename %s->%s in %s "

936 + "and deleted in %s",

937 + ren1_src, ren1_dst, branch1,

938 + branch2);

939 + update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, ren1_dst);

940 + } else if (!sha_eq(dst_other.sha1, null_sha1)) {

941 + const char *new_path;

942 + clean_merge = 0;

943 + try_merge = 1;

944 + output(1, "CONFLICT (rename/add): Rename %s->%s in %s. "

945 + "%s added in %s",

946 + ren1_src, ren1_dst, branch1,

947 + ren1_dst, branch2);

948 + new_path = unique_path(ren1_dst, branch2);

949 + output(1, "Adding as %s instead", new_path);

950 + update_file(0, dst_other.sha1, dst_other.mode, new_path);

951 + } else if ((item = string_list_lookup(ren1_dst, renames2Dst))) {

952 + ren2 = item->util;

953 + clean_merge = 0;

954 + ren2->processed = 1;

955 + output(1, "CONFLICT (rename/rename): Rename %s->%s in %s. "

956 + "Rename %s->%s in %s",

957 + ren1_src, ren1_dst, branch1,

958 + ren2->pair->one->path, ren2->pair->two->path, branch2);

959 + conflict_rename_rename_2(ren1, branch1, ren2, branch2);

960 + } else

961 + try_merge = 1;

962 +

963 + if (try_merge) {

964 + struct diff_filespec *o, *a, *b;

965 + struct merge_file_info mfi;

966 + src_other.path = (char *)ren1_src;

967 +

968 + o = ren1->pair->one;

969 + if (a_renames == renames1) {

970 + a = ren1->pair->two;

971 + b = &src_other;

972 + } else {

973 + b = ren1->pair->two;

974 + a = &src_other;

975 + }

976 + mfi = merge_file(o, a, b,

977 + a_branch, b_branch);

978 +

979 + if (mfi.clean &&

980 + sha_eq(mfi.sha, ren1->pair->two->sha1) &&

981 + mfi.mode == ren1->pair->two->mode)

982 + /*

983 + * This messaged is part of

984 + * t6022 test. If you change

985 + * it update the test too.

986 + */

987 + output(3, "Skipped %s (merged same as existing)", ren1_dst);

988 + else {

989 + if (mfi.merge || !mfi.clean)

990 + output(1, "Renaming %s => %s", ren1_src, ren1_dst);

991 + if (mfi.merge)

992 + output(2, "Auto-merging %s", ren1_dst);

993 + if (!mfi.clean) {

994 + output(1, "CONFLICT (rename/modify): Merge conflict in %s",

995 + ren1_dst);

996 + clean_merge = 0;

997 +

998 + if (!index_only)

999 + update_stages(ren1_dst,

1000 + o, a, b, 1);

1001 + }

1002 + update_file(mfi.clean, mfi.sha, mfi.mode, ren1_dst);

1003 + }

1004 + }

1005 + }

1006 + }

1007 + string_list_clear(&a_by_dst, 0);

1008 + string_list_clear(&b_by_dst, 0);

1009 +

1010 + return clean_merge;

1011 +}

1012 +

1013 +static unsigned char *stage_sha(const unsigned char *sha, unsigned mode)

1014 +{

1015 + return (is_null_sha1(sha) || mode == 0) ? NULL: (unsigned char *)sha;

1016 +}

1017 +

1018 +/* Per entry merge function */

1019 +static int process_entry(const char *path, struct stage_data *entry,

1020 + const char *branch1,

1021 + const char *branch2)

1022 +{

1023 + /*

1024 + printf("processing entry, clean cache: %s\n", index_only ? "yes": "no");

1025 + print_index_entry("\tpath: ", entry);

1026 + */

1027 + int clean_merge = 1;

1028 + unsigned o_mode = entry->stages[1].mode;

1029 + unsigned a_mode = entry->stages[2].mode;

1030 + unsigned b_mode = entry->stages[3].mode;

1031 + unsigned char *o_sha = stage_sha(entry->stages[1].sha, o_mode);

1032 + unsigned char *a_sha = stage_sha(entry->stages[2].sha, a_mode);

1033 + unsigned char *b_sha = stage_sha(entry->stages[3].sha, b_mode);

1034 +

1035 + if (o_sha && (!a_sha || !b_sha)) {

1036 + /* Case A: Deleted in one */

1037 + if ((!a_sha && !b_sha) ||

1038 + (sha_eq(a_sha, o_sha) && !b_sha) ||

1039 + (!a_sha && sha_eq(b_sha, o_sha))) {

1040 + /* Deleted in both or deleted in one and

1041 + * unchanged in the other */

1042 + if (a_sha)

1043 + output(2, "Removing %s", path);

1044 + /* do not touch working file if it did not exist */

1045 + remove_file(1, path, !a_sha);

1046 + } else {

1047 + /* Deleted in one and changed in the other */

1048 + clean_merge = 0;

1049 + if (!a_sha) {

1050 + output(1, "CONFLICT (delete/modify): %s deleted in %s "

1051 + "and modified in %s. Version %s of %s left in tree.",

1052 + path, branch1,

1053 + branch2, branch2, path);

1054 + update_file(0, b_sha, b_mode, path);

1055 + } else {

1056 + output(1, "CONFLICT (delete/modify): %s deleted in %s "

1057 + "and modified in %s. Version %s of %s left in tree.",

1058 + path, branch2,

1059 + branch1, branch1, path);

1060 + update_file(0, a_sha, a_mode, path);

1061 + }

1062 + }

1063 +

1064 + } else if ((!o_sha && a_sha && !b_sha) ||

1065 + (!o_sha && !a_sha && b_sha)) {

1066 + /* Case B: Added in one. */

1067 + const char *add_branch;

1068 + const char *other_branch;

1069 + unsigned mode;

1070 + const unsigned char *sha;

1071 + const char *conf;

1072 +

1073 + if (a_sha) {

1074 + add_branch = branch1;

1075 + other_branch = branch2;

1076 + mode = a_mode;

1077 + sha = a_sha;

1078 + conf = "file/directory";

1079 + } else {

1080 + add_branch = branch2;

1081 + other_branch = branch1;

1082 + mode = b_mode;

1083 + sha = b_sha;

1084 + conf = "directory/file";

1085 + }

1086 + if (string_list_has_string(&current_directory_set, path)) {

1087 + const char *new_path = unique_path(path, add_branch);

1088 + clean_merge = 0;

1089 + output(1, "CONFLICT (%s): There is a directory with name %s in %s. "

1090 + "Adding %s as %s",

1091 + conf, path, other_branch, path, new_path);

1092 + remove_file(0, path, 0);

1093 + update_file(0, sha, mode, new_path);

1094 + } else {

1095 + output(2, "Adding %s", path);

1096 + update_file(1, sha, mode, path);

1097 + }

1098 + } else if (a_sha && b_sha) {

1099 + /* Case C: Added in both (check for same permissions) and */

1100 + /* case D: Modified in both, but differently. */

1101 + const char *reason = "content";

1102 + struct merge_file_info mfi;

1103 + struct diff_filespec o, a, b;

1104 +

1105 + if (!o_sha) {

1106 + reason = "add/add";

1107 + o_sha = (unsigned char *)null_sha1;

1108 + }

1109 + output(2, "Auto-merging %s", path);

1110 + o.path = a.path = b.path = (char *)path;

1111 + hashcpy(o.sha1, o_sha);

1112 + o.mode = o_mode;

1113 + hashcpy(a.sha1, a_sha);

1114 + a.mode = a_mode;

1115 + hashcpy(b.sha1, b_sha);

1116 + b.mode = b_mode;

1117 +

1118 + mfi = merge_file(&o, &a, &b,

1119 + branch1, branch2);

1120 +

1121 + clean_merge = mfi.clean;

1122 + if (mfi.clean)

1123 + update_file(1, mfi.sha, mfi.mode, path);

1124 + else if (S_ISGITLINK(mfi.mode))

1125 + output(1, "CONFLICT (submodule): Merge conflict in %s "

1126 + "- needs %s", path, sha1_to_hex(b.sha1));

1127 + else {

1128 + output(1, "CONFLICT (%s): Merge conflict in %s",

1129 + reason, path);

1130 +

1131 + if (index_only)

1132 + update_file(0, mfi.sha, mfi.mode, path);

1133 + else

1134 + update_file_flags(mfi.sha, mfi.mode, path,

1135 + 0 /* update_cache */, 1 /* update_working_directory */);

1136 + }

1137 + } else if (!o_sha && !a_sha && !b_sha) {

1138 + /*

1139 + * this entry was deleted altogether. a_mode == 0 means

1140 + * we had that path and want to actively remove it.

1141 + */

1142 + remove_file(1, path, !a_mode);

1143 + } else

1144 + die("Fatal merge failure, shouldn't happen.");

1145 +

1146 + return clean_merge;

1147 +}

1148 +

1149 +int merge_trees(struct tree *head,

1150 + struct tree *merge,

1151 + struct tree *common,

1152 + const char *branch1,

1153 + const char *branch2,

1154 + struct tree **result)

1155 +{

1156 + int code, clean;

1157 +

1158 + if (subtree_merge) {

1159 + merge = shift_tree_object(head, merge);

1160 + common = shift_tree_object(head, common);

1161 + }

1162 +

1163 + if (sha_eq(common->object.sha1, merge->object.sha1)) {

1164 + output(0, "Already uptodate!");

1165 + *result = head;

1166 + return 1;

1167 + }

1168 +

1169 + code = git_merge_trees(index_only, common, head, merge);

1170 +

1171 + if (code != 0)

1172 + die("merging of trees %s and %s failed",

1173 + sha1_to_hex(head->object.sha1),

1174 + sha1_to_hex(merge->object.sha1));

1175 +

1176 + if (unmerged_cache()) {

1177 + struct string_list *entries, *re_head, *re_merge;

1178 + int i;

1179 + string_list_clear(&current_file_set, 1);

1180 + string_list_clear(&current_directory_set, 1);

1181 + get_files_dirs(head);

1182 + get_files_dirs(merge);

1183 +

1184 + entries = get_unmerged();

1185 + re_head = get_renames(head, common, head, merge, entries);

1186 + re_merge = get_renames(merge, common, head, merge, entries);

1187 + clean = process_renames(re_head, re_merge,

1188 + branch1, branch2);

1189 + for (i = 0; i < entries->nr; i++) {

1190 + const char *path = entries->items[i].string;

1191 + struct stage_data *e = entries->items[i].util;

1192 + if (!e->processed

1193 + && !process_entry(path, e, branch1, branch2))

1194 + clean = 0;

1195 + }

1196 +

1197 + string_list_clear(re_merge, 0);

1198 + string_list_clear(re_head, 0);

1199 + string_list_clear(entries, 1);

1200 +

1201 + }

1202 + else

1203 + clean = 1;

1204 +

1205 + if (index_only)

1206 + *result = write_tree_from_memory();

1207 +

1208 + return clean;

1209 +}

1210 +

1211 +static struct commit_list *reverse_commit_list(struct commit_list *list)

1212 +{

1213 + struct commit_list *next = NULL, *current, *backup;

1214 + for (current = list; current; current = backup) {

1215 + backup = current->next;

1216 + current->next = next;

1217 + next = current;

1218 + }

1219 + return next;

1220 +}

1221 +

1222 +/*

1223 + * Merge the commits h1 and h2, return the resulting virtual

1224 + * commit object and a flag indicating the cleanness of the merge.

1225 + */

1226 +int merge_recursive(struct commit *h1,

1227 + struct commit *h2,

1228 + const char *branch1,

1229 + const char *branch2,

1230 + struct commit_list *ca,

1231 + struct commit **result)

1232 +{

1233 + struct commit_list *iter;

1234 + struct commit *merged_common_ancestors;

1235 + struct tree *mrtree = mrtree;

1236 + int clean;

1237 +

1238 + if (show(4)) {

1239 + output(4, "Merging:");

1240 + output_commit_title(h1);

1241 + output_commit_title(h2);

1242 + }

1243 +

1244 + if (!ca) {

1245 + ca = get_merge_bases(h1, h2, 1);

1246 + ca = reverse_commit_list(ca);

1247 + }

1248 +

1249 + if (show(5)) {

1250 + output(5, "found %u common ancestor(s):", commit_list_count(ca));

1251 + for (iter = ca; iter; iter = iter->next)

1252 + output_commit_title(iter->item);

1253 + }

1254 +

1255 + merged_common_ancestors = pop_commit(&ca);

1256 + if (merged_common_ancestors == NULL) {

1257 + /* if there is no common ancestor, make an empty tree */

1258 + struct tree *tree = xcalloc(1, sizeof(struct tree));

1259 +

1260 + tree->object.parsed = 1;

1261 + tree->object.type = OBJ_TREE;

1262 + pretend_sha1_file(NULL, 0, OBJ_TREE, tree->object.sha1);

1263 + merged_common_ancestors = make_virtual_commit(tree, "ancestor");

1264 + }

1265 +

1266 + for (iter = ca; iter; iter = iter->next) {

1267 + call_depth++;

1268 + /*

1269 + * When the merge fails, the result contains files

1270 + * with conflict markers. The cleanness flag is

1271 + * ignored, it was never actually used, as result of

1272 + * merge_trees has always overwritten it: the committed

1273 + * "conflicts" were already resolved.

1274 + */

1275 + discard_cache();

1276 + merge_recursive(merged_common_ancestors, iter->item,

1277 + "Temporary merge branch 1",

1278 + "Temporary merge branch 2",

1279 + NULL,

1280 + &merged_common_ancestors);

1281 + call_depth--;

1282 +

1283 + if (!merged_common_ancestors)

1284 + die("merge returned no commit");

1285 + }

1286 +

1287 + discard_cache();

1288 + if (!call_depth) {

1289 + read_cache();

1290 + index_only = 0;

1291 + } else

1292 + index_only = 1;

1293 +

1294 + clean = merge_trees(h1->tree, h2->tree, merged_common_ancestors->tree,

1295 + branch1, branch2, &mrtree);

1296 +

1297 + if (index_only) {

1298 + *result = make_virtual_commit(mrtree, "merged tree");

1299 + commit_list_insert(h1, &(*result)->parents);

1300 + commit_list_insert(h2, &(*result)->parents->next);

1301 + }

1302 + flush_output();

1303 + return clean;

1304 +}

1305 +

1306 +int merge_recursive_config(const char *var, const char *value, void *cb)

1307 +{

1308 + if (!strcasecmp(var, "merge.verbosity")) {

1309 + merge_recursive_verbosity = git_config_int(var, value);

1310 + return 0;

1311 + }

1312 + if (!strcasecmp(var, "diff.renamelimit")) {

1313 + diff_rename_limit = git_config_int(var, value);

1314 + return 0;

1315 + }

1316 + if (!strcasecmp(var, "merge.renamelimit")) {

1317 + merge_rename_limit = git_config_int(var, value);

1318 + return 0;

1319 + }

1320 + return git_default_config(var, value, cb);

1321 +}

1322 +

1323 +void merge_recursive_setup(int is_subtree_merge)

1324 +{

1325 + if (getenv("GIT_MERGE_VERBOSITY"))

1326 + merge_recursive_verbosity =

1327 + strtol(getenv("GIT_MERGE_VERBOSITY"), NULL, 10);

1328 + if (merge_recursive_verbosity >= 5)

1329 + buffer_output = 0;

1330 + subtree_merge = is_subtree_merge;

1331 +}

merge-recursive.h

+5 -1

@@ -14,7 +14,11 @@ int merge_trees(struct tree *head,

14 const char *branch1,

15 const char *branch2,

16 struct tree **result);

17 -

17 +struct commit *make_virtual_commit(struct tree *tree, const char *comment);

18 +int merge_recursive_config(const char *var, const char *value, void *cb);

19 +void merge_recursive_setup(int is_subtree_merge);

20 struct tree *write_tree_from_memory(void);

22 +extern int merge_recursive_verbosity;

23 +

24 #endif