merge: force edit and no-ff mode when merging a tag object
[git/git.git] / commit.c
CommitLineData
8f1d2e6f 1#include "cache.h"
961784ee 2#include "tag.h"
175785e5 3#include "commit.h"
ed09aef0 4#include "pkt-line.h"
52883fbd 5#include "utf8.h"
199c45bf
JH
6#include "diff.h"
7#include "revision.h"
a97a7468 8#include "notes.h"
175785e5 9
60ab26de
LT
10int save_commit_buffer = 1;
11
175785e5
DB
12const char *commit_type = "commit";
13
f76412ed
JH
14static struct commit *check_commit(struct object *obj,
15 const unsigned char *sha1,
16 int quiet)
961784ee 17{
1974632c 18 if (obj->type != OBJ_COMMIT) {
f76412ed
JH
19 if (!quiet)
20 error("Object %s is a %s, not a commit",
885a86ab 21 sha1_to_hex(sha1), typename(obj->type));
961784ee
LT
22 return NULL;
23 }
24 return (struct commit *) obj;
25}
26
f76412ed
JH
27struct commit *lookup_commit_reference_gently(const unsigned char *sha1,
28 int quiet)
961784ee 29{
9534f40b 30 struct object *obj = deref_tag(parse_object(sha1), NULL, 0);
961784ee
LT
31
32 if (!obj)
33 return NULL;
f76412ed
JH
34 return check_commit(obj, sha1, quiet);
35}
36
37struct commit *lookup_commit_reference(const unsigned char *sha1)
38{
39 return lookup_commit_reference_gently(sha1, 0);
961784ee
LT
40}
41
baf18fc2
NTND
42struct commit *lookup_commit_or_die(const unsigned char *sha1, const char *ref_name)
43{
44 struct commit *c = lookup_commit_reference(sha1);
45 if (!c)
46 die(_("could not parse %s"), ref_name);
47 if (hashcmp(sha1, c->object.sha1)) {
48 warning(_("%s %s is not a commit!"),
49 ref_name, sha1_to_hex(sha1));
50 }
51 return c;
52}
53
5d6ccf5c 54struct commit *lookup_commit(const unsigned char *sha1)
175785e5
DB
55{
56 struct object *obj = lookup_object(sha1);
100c5f3b
LT
57 if (!obj)
58 return create_object(sha1, OBJ_COMMIT, alloc_commit_node());
d1af002d 59 if (!obj->type)
1974632c 60 obj->type = OBJ_COMMIT;
f76412ed 61 return check_commit(obj, sha1, 0);
175785e5
DB
62}
63
a6fa5992
PN
64struct commit *lookup_commit_reference_by_name(const char *name)
65{
66 unsigned char sha1[20];
67 struct commit *commit;
68
69 if (get_sha1(name, sha1))
70 return NULL;
71 commit = lookup_commit_reference(sha1);
72 if (!commit || parse_commit(commit))
73 return NULL;
74 return commit;
75}
76
0a617799 77static unsigned long parse_commit_date(const char *buf, const char *tail)
175785e5 78{
0a617799 79 const char *dateptr;
175785e5 80
0a617799
MK
81 if (buf + 6 >= tail)
82 return 0;
175785e5
DB
83 if (memcmp(buf, "author", 6))
84 return 0;
0a617799 85 while (buf < tail && *buf++ != '\n')
175785e5 86 /* nada */;
0a617799
MK
87 if (buf + 9 >= tail)
88 return 0;
175785e5
DB
89 if (memcmp(buf, "committer", 9))
90 return 0;
0a617799 91 while (buf < tail && *buf++ != '>')
175785e5 92 /* nada */;
0a617799
MK
93 if (buf >= tail)
94 return 0;
95 dateptr = buf;
96 while (buf < tail && *buf++ != '\n')
97 /* nada */;
98 if (buf >= tail)
99 return 0;
100 /* dateptr < buf && buf[-1] == '\n', so strtoul will stop at buf-1 */
f2909743 101 return strtoul(dateptr, NULL, 10);
175785e5
DB
102}
103
5040f17e 104static struct commit_graft **commit_graft;
5da5c8f4
JH
105static int commit_graft_alloc, commit_graft_nr;
106
107static int commit_graft_pos(const unsigned char *sha1)
108{
109 int lo, hi;
110 lo = 0;
111 hi = commit_graft_nr;
112 while (lo < hi) {
113 int mi = (lo + hi) / 2;
114 struct commit_graft *graft = commit_graft[mi];
a89fccd2 115 int cmp = hashcmp(sha1, graft->sha1);
5da5c8f4
JH
116 if (!cmp)
117 return mi;
118 if (cmp < 0)
119 hi = mi;
120 else
121 lo = mi + 1;
122 }
123 return -lo - 1;
124}
125
5040f17e
JH
126int register_commit_graft(struct commit_graft *graft, int ignore_dups)
127{
128 int pos = commit_graft_pos(graft->sha1);
a6080a0a 129
5040f17e
JH
130 if (0 <= pos) {
131 if (ignore_dups)
132 free(graft);
133 else {
134 free(commit_graft[pos]);
135 commit_graft[pos] = graft;
136 }
137 return 1;
138 }
139 pos = -pos - 1;
140 if (commit_graft_alloc <= ++commit_graft_nr) {
141 commit_graft_alloc = alloc_nr(commit_graft_alloc);
142 commit_graft = xrealloc(commit_graft,
143 sizeof(*commit_graft) *
144 commit_graft_alloc);
145 }
146 if (pos < commit_graft_nr)
147 memmove(commit_graft + pos + 1,
148 commit_graft + pos,
149 (commit_graft_nr - pos - 1) *
150 sizeof(*commit_graft));
151 commit_graft[pos] = graft;
152 return 0;
153}
154
155struct commit_graft *read_graft_line(char *buf, int len)
156{
157 /* The format is just "Commit Parent1 Parent2 ...\n" */
158 int i;
159 struct commit_graft *graft = NULL;
160
fe0a3cb2
JH
161 while (len && isspace(buf[len-1]))
162 buf[--len] = '\0';
360204c3 163 if (buf[0] == '#' || buf[0] == '\0')
5bc4ce58 164 return NULL;
df5d43be
RT
165 if ((len + 1) % 41)
166 goto bad_graft_data;
5040f17e
JH
167 i = (len + 1) / 41 - 1;
168 graft = xmalloc(sizeof(*graft) + 20 * i);
169 graft->nr_parent = i;
170 if (get_sha1_hex(buf, graft->sha1))
171 goto bad_graft_data;
172 for (i = 40; i < len; i += 41) {
173 if (buf[i] != ' ')
174 goto bad_graft_data;
175 if (get_sha1_hex(buf + i + 1, graft->parent[i/41]))
176 goto bad_graft_data;
177 }
178 return graft;
df5d43be
RT
179
180bad_graft_data:
181 error("bad graft data: %s", buf);
182 free(graft);
183 return NULL;
5040f17e
JH
184}
185
c5ae6439 186static int read_graft_file(const char *graft_file)
5da5c8f4 187{
5da5c8f4
JH
188 FILE *fp = fopen(graft_file, "r");
189 char buf[1024];
5040f17e
JH
190 if (!fp)
191 return -1;
5da5c8f4
JH
192 while (fgets(buf, sizeof(buf), fp)) {
193 /* The format is just "Commit Parent1 Parent2 ...\n" */
194 int len = strlen(buf);
5040f17e 195 struct commit_graft *graft = read_graft_line(buf, len);
5bc4ce58
JH
196 if (!graft)
197 continue;
5040f17e 198 if (register_commit_graft(graft, 1))
5da5c8f4 199 error("duplicate graft data: %s", buf);
5da5c8f4
JH
200 }
201 fclose(fp);
5040f17e
JH
202 return 0;
203}
204
205static void prepare_commit_graft(void)
206{
207 static int commit_graft_prepared;
208 char *graft_file;
209
210 if (commit_graft_prepared)
211 return;
212 graft_file = get_graft_file();
213 read_graft_file(graft_file);
ed09aef0
JS
214 /* make sure shallows are read */
215 is_repository_shallow();
5040f17e 216 commit_graft_prepared = 1;
5da5c8f4
JH
217}
218
45163382 219struct commit_graft *lookup_commit_graft(const unsigned char *sha1)
5da5c8f4
JH
220{
221 int pos;
5040f17e 222 prepare_commit_graft();
5da5c8f4
JH
223 pos = commit_graft_pos(sha1);
224 if (pos < 0)
225 return NULL;
226 return commit_graft[pos];
227}
228
09d46644 229int for_each_commit_graft(each_commit_graft_fn fn, void *cb_data)
ed09aef0 230{
09d46644
NTND
231 int i, ret;
232 for (i = ret = 0; i < commit_graft_nr && !ret; i++)
233 ret = fn(commit_graft[i], cb_data);
234 return ret;
ed09aef0
JS
235}
236
f53514bc
JS
237int unregister_shallow(const unsigned char *sha1)
238{
239 int pos = commit_graft_pos(sha1);
240 if (pos < 0)
241 return -1;
242 if (pos + 1 < commit_graft_nr)
65d41d48 243 memmove(commit_graft + pos, commit_graft + pos + 1,
f53514bc
JS
244 sizeof(struct commit_graft *)
245 * (commit_graft_nr - pos - 1));
246 commit_graft_nr--;
247 return 0;
248}
249
cf7b1cad 250int parse_commit_buffer(struct commit *item, const void *buffer, unsigned long size)
175785e5 251{
cf7b1cad
NTND
252 const char *tail = buffer;
253 const char *bufptr = buffer;
175785e5 254 unsigned char parent[20];
6c88be16 255 struct commit_list **pptr;
5da5c8f4 256 struct commit_graft *graft;
bd2c39f5 257
175785e5
DB
258 if (item->object.parsed)
259 return 0;
260 item->object.parsed = 1;
3b44f15a 261 tail += size;
0a617799 262 if (tail <= bufptr + 46 || memcmp(bufptr, "tree ", 5) || bufptr[45] != '\n')
f7cc77d7 263 return error("bogus commit object %s", sha1_to_hex(item->object.sha1));
0a617799 264 if (get_sha1_hex(bufptr + 5, parent) < 0)
bd2afde8
JH
265 return error("bad tree pointer in commit %s",
266 sha1_to_hex(item->object.sha1));
175785e5 267 item->tree = lookup_tree(parent);
175785e5 268 bufptr += 46; /* "tree " + "hex sha1" + "\n" */
6c88be16 269 pptr = &item->parents;
5da5c8f4
JH
270
271 graft = lookup_commit_graft(item->object.sha1);
3b44f15a 272 while (bufptr + 48 < tail && !memcmp(bufptr, "parent ", 7)) {
f7cc77d7
LT
273 struct commit *new_parent;
274
3b44f15a
JH
275 if (tail <= bufptr + 48 ||
276 get_sha1_hex(bufptr + 7, parent) ||
277 bufptr[47] != '\n')
f7cc77d7 278 return error("bad parents in commit %s", sha1_to_hex(item->object.sha1));
5da5c8f4 279 bufptr += 48;
7f3140cd
JS
280 /*
281 * The clone is shallow if nr_parent < 0, and we must
282 * not traverse its real parents even when we unhide them.
283 */
284 if (graft && (graft->nr_parent < 0 || grafts_replace_parents))
5da5c8f4 285 continue;
f7cc77d7 286 new_parent = lookup_commit(parent);
39468def 287 if (new_parent)
6c88be16 288 pptr = &commit_list_insert(new_parent, pptr)->next;
5da5c8f4
JH
289 }
290 if (graft) {
291 int i;
292 struct commit *new_parent;
293 for (i = 0; i < graft->nr_parent; i++) {
294 new_parent = lookup_commit(graft->parent[i]);
295 if (!new_parent)
296 continue;
297 pptr = &commit_list_insert(new_parent, pptr)->next;
5da5c8f4 298 }
175785e5 299 }
0a617799 300 item->date = parse_commit_date(bufptr, tail);
27dedf0c 301
175785e5
DB
302 return 0;
303}
304
bd2c39f5
NP
305int parse_commit(struct commit *item)
306{
21666f1a 307 enum object_type type;
bd2c39f5
NP
308 void *buffer;
309 unsigned long size;
310 int ret;
311
9786f68b
MK
312 if (!item)
313 return -1;
bd2c39f5
NP
314 if (item->object.parsed)
315 return 0;
21666f1a 316 buffer = read_sha1_file(item->object.sha1, &type, &size);
bd2c39f5
NP
317 if (!buffer)
318 return error("Could not read %s",
319 sha1_to_hex(item->object.sha1));
21666f1a 320 if (type != OBJ_COMMIT) {
bd2c39f5
NP
321 free(buffer);
322 return error("Object %s not a commit",
323 sha1_to_hex(item->object.sha1));
324 }
325 ret = parse_commit_buffer(item, buffer, size);
60ab26de 326 if (save_commit_buffer && !ret) {
3ff1fbbb
LT
327 item->buffer = buffer;
328 return 0;
329 }
bd2c39f5
NP
330 free(buffer);
331 return ret;
332}
333
11af2aae
CC
334int find_commit_subject(const char *commit_buffer, const char **subject)
335{
336 const char *eol;
337 const char *p = commit_buffer;
338
339 while (*p && (*p != '\n' || p[1] != '\n'))
340 p++;
341 if (*p) {
342 p += 2;
343 for (eol = p; *eol && *eol != '\n'; eol++)
344 ; /* do nothing */
345 } else
346 eol = p;
347
348 *subject = p;
349
350 return eol - p;
351}
352
ac5155ef 353struct commit_list *commit_list_insert(struct commit *item, struct commit_list **list_p)
dd97f850 354{
812666c8 355 struct commit_list *new_list = xmalloc(sizeof(struct commit_list));
dd97f850
DB
356 new_list->item = item;
357 new_list->next = *list_p;
358 *list_p = new_list;
ac5155ef 359 return new_list;
dd97f850
DB
360}
361
65319475
MV
362unsigned commit_list_count(const struct commit_list *l)
363{
364 unsigned c = 0;
365 for (; l; l = l->next )
366 c++;
367 return c;
368}
369
175785e5
DB
370void free_commit_list(struct commit_list *list)
371{
372 while (list) {
373 struct commit_list *temp = list;
374 list = temp->next;
375 free(temp);
376 }
377}
dd97f850 378
47e44ed1 379struct commit_list * commit_list_insert_by_date(struct commit *item, struct commit_list **list)
dd97f850
DB
380{
381 struct commit_list **pp = list;
382 struct commit_list *p;
383 while ((p = *pp) != NULL) {
384 if (p->item->date < item->date) {
385 break;
386 }
387 pp = &p->next;
388 }
f755494c 389 return commit_list_insert(item, pp);
dd97f850
DB
390}
391
a6080a0a 392
47e44ed1 393void commit_list_sort_by_date(struct commit_list **list)
dd97f850
DB
394{
395 struct commit_list *ret = NULL;
396 while (*list) {
47e44ed1 397 commit_list_insert_by_date((*list)->item, &ret);
dd97f850
DB
398 *list = (*list)->next;
399 }
400 *list = ret;
401}
402
58e28af6
DB
403struct commit *pop_most_recent_commit(struct commit_list **list,
404 unsigned int mark)
dd97f850
DB
405{
406 struct commit *ret = (*list)->item;
407 struct commit_list *parents = ret->parents;
408 struct commit_list *old = *list;
409
410 *list = (*list)->next;
411 free(old);
412
413 while (parents) {
4056c091 414 struct commit *commit = parents->item;
dec38c81 415 if (!parse_commit(commit) && !(commit->object.flags & mark)) {
58e28af6 416 commit->object.flags |= mark;
47e44ed1 417 commit_list_insert_by_date(commit, list);
4056c091 418 }
dd97f850
DB
419 parents = parents->next;
420 }
421 return ret;
422}
e3bc7a3b 423
f8f9c73c
JH
424void clear_commit_marks(struct commit *commit, unsigned int mark)
425{
60fcc2e6
JS
426 while (commit) {
427 struct commit_list *parents;
f8f9c73c 428
60fcc2e6
JS
429 if (!(mark & commit->object.flags))
430 return;
58ecf5c1 431
60fcc2e6
JS
432 commit->object.flags &= ~mark;
433
434 parents = commit->parents;
435 if (!parents)
436 return;
437
438 while ((parents = parents->next))
439 clear_commit_marks(parents->item, mark);
440
441 commit = commit->parents->item;
f8f9c73c
JH
442 }
443}
444
86a0a408
RS
445void clear_commit_marks_for_object_array(struct object_array *a, unsigned mark)
446{
447 struct object *object;
448 struct commit *commit;
449 unsigned int i;
450
451 for (i = 0; i < a->nr; i++) {
452 object = a->objects[i].item;
453 commit = lookup_commit_reference_gently(object->sha1, 1);
454 if (commit)
455 clear_commit_marks(commit, mark);
456 }
457}
458
a3437b8c
JS
459struct commit *pop_commit(struct commit_list **stack)
460{
461 struct commit_list *top = *stack;
462 struct commit *item = top ? top->item : NULL;
463
464 if (top) {
465 *stack = top->next;
466 free(top);
467 }
468 return item;
469}
470
ab580ace
JS
471/*
472 * Performs an in-place topological sort on the list supplied.
473 */
4c8725f1 474void sort_in_topological_order(struct commit_list ** list, int lifo)
6b6dcfc2 475{
23c17d4a
LT
476 struct commit_list *next, *orig = *list;
477 struct commit_list *work, **insert;
478 struct commit_list **pptr;
a6080a0a 479
23c17d4a 480 if (!orig)
7d6fb370 481 return;
23c17d4a
LT
482 *list = NULL;
483
484 /* Mark them and clear the indegree */
485 for (next = orig; next; next = next->next) {
486 struct commit *commit = next->item;
e358f3c3 487 commit->indegree = 1;
ab580ace 488 }
23c17d4a 489
ab580ace 490 /* update the indegree */
23c17d4a 491 for (next = orig; next; next = next->next) {
ab580ace
JS
492 struct commit_list * parents = next->item->parents;
493 while (parents) {
23c17d4a 494 struct commit *parent = parents->item;
6b6dcfc2 495
e358f3c3 496 if (parent->indegree)
23c17d4a
LT
497 parent->indegree++;
498 parents = parents->next;
ab580ace 499 }
ab580ace 500 }
23c17d4a 501
a6080a0a 502 /*
674d1727
PH
503 * find the tips
504 *
505 * tips are nodes not reachable from any other node in the list
506 *
507 * the tips serve as a starting set for the work queue.
508 */
23c17d4a 509 work = NULL;
2ed02887 510 insert = &work;
23c17d4a
LT
511 for (next = orig; next; next = next->next) {
512 struct commit *commit = next->item;
ab580ace 513
e358f3c3 514 if (commit->indegree == 1)
23c17d4a 515 insert = &commit_list_insert(commit, insert)->next;
ab580ace 516 }
4c8725f1 517
ab580ace 518 /* process the list in topological order */
4c8725f1 519 if (!lifo)
47e44ed1 520 commit_list_sort_by_date(&work);
23c17d4a
LT
521
522 pptr = list;
523 *list = NULL;
ab580ace 524 while (work) {
23c17d4a
LT
525 struct commit *commit;
526 struct commit_list *parents, *work_item;
ab580ace 527
23c17d4a
LT
528 work_item = work;
529 work = work_item->next;
530 work_item->next = NULL;
531
532 commit = work_item->item;
533 for (parents = commit->parents; parents ; parents = parents->next) {
cd2b8ae9 534 struct commit *parent = parents->item;
23c17d4a 535
e358f3c3 536 if (!parent->indegree)
23c17d4a
LT
537 continue;
538
539 /*
540 * parents are only enqueued for emission
541 * when all their children have been emitted thereby
542 * guaranteeing topological order.
543 */
e358f3c3 544 if (--parent->indegree == 1) {
23c17d4a 545 if (!lifo)
47e44ed1 546 commit_list_insert_by_date(parent, &work);
23c17d4a
LT
547 else
548 commit_list_insert(parent, &work);
ab580ace 549 }
ab580ace
JS
550 }
551 /*
674d1727
PH
552 * work_item is a commit all of whose children
553 * have already been emitted. we can emit it now.
554 */
e358f3c3 555 commit->indegree = 0;
23c17d4a
LT
556 *pptr = work_item;
557 pptr = &work_item->next;
ab580ace 558 }
ab580ace 559}
7c6f8aaf 560
1295228d 561/* merge-base stuff */
7c6f8aaf 562
577ed5c2
JH
563/* bits #0..15 in revision.h */
564#define PARENT1 (1u<<16)
565#define PARENT2 (1u<<17)
566#define STALE (1u<<18)
567#define RESULT (1u<<19)
7c6f8aaf 568
1295228d
JH
569static const unsigned all_flags = (PARENT1 | PARENT2 | STALE | RESULT);
570
7c6f8aaf
JS
571static struct commit *interesting(struct commit_list *list)
572{
573 while (list) {
574 struct commit *commit = list->item;
575 list = list->next;
542ccefe 576 if (commit->object.flags & STALE)
7c6f8aaf
JS
577 continue;
578 return commit;
579 }
580 return NULL;
581}
582
6a938648 583static struct commit_list *merge_bases_many(struct commit *one, int n, struct commit **twos)
7c6f8aaf
JS
584{
585 struct commit_list *list = NULL;
586 struct commit_list *result = NULL;
6a938648 587 int i;
7c6f8aaf 588
6a938648
JH
589 for (i = 0; i < n; i++) {
590 if (one == twos[i])
591 /*
592 * We do not mark this even with RESULT so we do not
593 * have to clean it up.
594 */
595 return commit_list_insert(one, &result);
596 }
7c6f8aaf 597
172947e6
MK
598 if (parse_commit(one))
599 return NULL;
6a938648
JH
600 for (i = 0; i < n; i++) {
601 if (parse_commit(twos[i]))
602 return NULL;
603 }
7c6f8aaf 604
f3249438 605 one->object.flags |= PARENT1;
47e44ed1 606 commit_list_insert_by_date(one, &list);
6a938648
JH
607 for (i = 0; i < n; i++) {
608 twos[i]->object.flags |= PARENT2;
47e44ed1 609 commit_list_insert_by_date(twos[i], &list);
6a938648 610 }
7c6f8aaf
JS
611
612 while (interesting(list)) {
f3249438 613 struct commit *commit;
7c6f8aaf 614 struct commit_list *parents;
f203d696 615 struct commit_list *next;
f3249438 616 int flags;
7c6f8aaf 617
f3249438 618 commit = list->item;
f203d696 619 next = list->next;
f3249438 620 free(list);
f203d696 621 list = next;
7c6f8aaf 622
f3249438
JH
623 flags = commit->object.flags & (PARENT1 | PARENT2 | STALE);
624 if (flags == (PARENT1 | PARENT2)) {
625 if (!(commit->object.flags & RESULT)) {
626 commit->object.flags |= RESULT;
47e44ed1 627 commit_list_insert_by_date(commit, &result);
f3249438 628 }
542ccefe
JH
629 /* Mark parents of a found merge stale */
630 flags |= STALE;
7c6f8aaf
JS
631 }
632 parents = commit->parents;
633 while (parents) {
634 struct commit *p = parents->item;
635 parents = parents->next;
636 if ((p->object.flags & flags) == flags)
637 continue;
172947e6
MK
638 if (parse_commit(p))
639 return NULL;
7c6f8aaf 640 p->object.flags |= flags;
47e44ed1 641 commit_list_insert_by_date(p, &list);
7c6f8aaf
JS
642 }
643 }
644
f3249438 645 /* Clean up the result to remove stale ones */
1295228d 646 free_commit_list(list);
f3249438
JH
647 list = result; result = NULL;
648 while (list) {
f203d696 649 struct commit_list *next = list->next;
f3249438 650 if (!(list->item->object.flags & STALE))
47e44ed1 651 commit_list_insert_by_date(list->item, &result);
f3249438 652 free(list);
f203d696 653 list = next;
f3249438
JH
654 }
655 return result;
656}
7c6f8aaf 657
5240c9d7
MV
658struct commit_list *get_octopus_merge_bases(struct commit_list *in)
659{
660 struct commit_list *i, *j, *k, *ret = NULL;
661 struct commit_list **pptr = &ret;
662
663 for (i = in; i; i = i->next) {
664 if (!ret)
665 pptr = &commit_list_insert(i->item, pptr)->next;
666 else {
667 struct commit_list *new = NULL, *end = NULL;
668
669 for (j = ret; j; j = j->next) {
670 struct commit_list *bases;
671 bases = get_merge_bases(i->item, j->item, 1);
672 if (!new)
673 new = bases;
674 else
675 end->next = bases;
676 for (k = bases; k; k = k->next)
677 end = k;
678 }
679 ret = new;
680 }
681 }
682 return ret;
683}
684
6a938648
JH
685struct commit_list *get_merge_bases_many(struct commit *one,
686 int n,
687 struct commit **twos,
688 int cleanup)
f3249438 689{
f3249438
JH
690 struct commit_list *list;
691 struct commit **rslt;
692 struct commit_list *result;
693 int cnt, i, j;
694
6a938648
JH
695 result = merge_bases_many(one, n, twos);
696 for (i = 0; i < n; i++) {
697 if (one == twos[i])
698 return result;
699 }
f3249438
JH
700 if (!result || !result->next) {
701 if (cleanup) {
702 clear_commit_marks(one, all_flags);
6a938648
JH
703 for (i = 0; i < n; i++)
704 clear_commit_marks(twos[i], all_flags);
7c6f8aaf 705 }
f3249438 706 return result;
7c6f8aaf
JS
707 }
708
f3249438
JH
709 /* There are more than one */
710 cnt = 0;
711 list = result;
712 while (list) {
713 list = list->next;
714 cnt++;
715 }
716 rslt = xcalloc(cnt, sizeof(*rslt));
717 for (list = result, i = 0; list; list = list->next)
718 rslt[i++] = list->item;
719 free_commit_list(result);
720
721 clear_commit_marks(one, all_flags);
6a938648
JH
722 for (i = 0; i < n; i++)
723 clear_commit_marks(twos[i], all_flags);
f3249438
JH
724 for (i = 0; i < cnt - 1; i++) {
725 for (j = i+1; j < cnt; j++) {
726 if (!rslt[i] || !rslt[j])
727 continue;
6a938648 728 result = merge_bases_many(rslt[i], 1, &rslt[j]);
f3249438
JH
729 clear_commit_marks(rslt[i], all_flags);
730 clear_commit_marks(rslt[j], all_flags);
731 for (list = result; list; list = list->next) {
732 if (rslt[i] == list->item)
733 rslt[i] = NULL;
734 if (rslt[j] == list->item)
735 rslt[j] = NULL;
736 }
737 }
58ecf5c1 738 }
7c6f8aaf 739
f3249438
JH
740 /* Surviving ones in rslt[] are the independent results */
741 result = NULL;
742 for (i = 0; i < cnt; i++) {
743 if (rslt[i])
47e44ed1 744 commit_list_insert_by_date(rslt[i], &result);
f3249438
JH
745 }
746 free(rslt);
7c6f8aaf
JS
747 return result;
748}
2ecd2bbc 749
6a938648
JH
750struct commit_list *get_merge_bases(struct commit *one, struct commit *two,
751 int cleanup)
752{
753 return get_merge_bases_many(one, 1, &two, cleanup);
754}
755
7fcdb36e
JG
756int is_descendant_of(struct commit *commit, struct commit_list *with_commit)
757{
758 if (!with_commit)
759 return 1;
760 while (with_commit) {
761 struct commit *other;
762
763 other = with_commit->item;
764 with_commit = with_commit->next;
765 if (in_merge_bases(other, &commit, 1))
766 return 1;
767 }
768 return 0;
769}
770
03840fc3 771int in_merge_bases(struct commit *commit, struct commit **reference, int num)
2ecd2bbc
JH
772{
773 struct commit_list *bases, *b;
774 int ret = 0;
775
03840fc3
JH
776 if (num == 1)
777 bases = get_merge_bases(commit, *reference, 1);
778 else
779 die("not yet");
2ecd2bbc 780 for (b = bases; b; b = b->next) {
03840fc3 781 if (!hashcmp(commit->object.sha1, b->item->object.sha1)) {
2ecd2bbc
JH
782 ret = 1;
783 break;
784 }
785 }
786
787 free_commit_list(bases);
788 return ret;
789}
98cf9c3b
JH
790
791struct commit_list *reduce_heads(struct commit_list *heads)
792{
793 struct commit_list *p;
794 struct commit_list *result = NULL, **tail = &result;
795 struct commit **other;
796 size_t num_head, num_other;
797
798 if (!heads)
799 return NULL;
800
801 /* Avoid unnecessary reallocations */
802 for (p = heads, num_head = 0; p; p = p->next)
803 num_head++;
804 other = xcalloc(sizeof(*other), num_head);
805
806 /* For each commit, see if it can be reached by others */
807 for (p = heads; p; p = p->next) {
808 struct commit_list *q, *base;
809
711f6b29
JH
810 /* Do we already have this in the result? */
811 for (q = result; q; q = q->next)
812 if (p->item == q->item)
813 break;
814 if (q)
815 continue;
816
98cf9c3b
JH
817 num_other = 0;
818 for (q = heads; q; q = q->next) {
3d1dd472 819 if (p->item == q->item)
98cf9c3b
JH
820 continue;
821 other[num_other++] = q->item;
822 }
711f6b29 823 if (num_other)
98cf9c3b 824 base = get_merge_bases_many(p->item, num_other, other, 1);
711f6b29 825 else
98cf9c3b
JH
826 base = NULL;
827 /*
828 * If p->item does not have anything common with other
829 * commits, there won't be any merge base. If it is
830 * reachable from some of the others, p->item will be
831 * the merge base. If its history is connected with
832 * others, but p->item is not reachable by others, we
833 * will get something other than p->item back.
834 */
835 if (!base || (base->item != p->item))
836 tail = &(commit_list_insert(p->item, tail)->next);
837 free_commit_list(base);
838 }
839 free(other);
840 return result;
841}
40d52ff7 842
5231c633
JH
843static void handle_signed_tag(struct commit *parent, struct commit_extra_header ***tail)
844{
845 struct merge_remote_desc *desc;
846 struct commit_extra_header *mergetag;
847 char *buf;
848 unsigned long size, len;
849 enum object_type type;
850
851 desc = merge_remote_util(parent);
852 if (!desc || !desc->obj)
853 return;
854 buf = read_sha1_file(desc->obj->sha1, &type, &size);
855 if (!buf || type != OBJ_TAG)
856 goto free_return;
857 len = parse_signature(buf, size);
858 if (size == len)
859 goto free_return;
860 /*
861 * We could verify this signature and either omit the tag when
862 * it does not validate, but the integrator may not have the
863 * public key of the signer of the tag he is merging, while a
864 * later auditor may have it while auditing, so let's not run
865 * verify-signed-buffer here for now...
866 *
867 * if (verify_signed_buffer(buf, len, buf + len, size - len, ...))
868 * warn("warning: signed tag unverified.");
869 */
870 mergetag = xcalloc(1, sizeof(*mergetag));
871 mergetag->key = xstrdup("mergetag");
872 mergetag->value = buf;
873 mergetag->len = size;
874
875 **tail = mergetag;
876 *tail = &mergetag->next;
877 return;
878
879free_return:
880 free(buf);
881}
882
883void append_merge_tag_headers(struct commit_list *parents,
884 struct commit_extra_header ***tail)
885{
886 while (parents) {
887 struct commit *parent = parents->item;
888 handle_signed_tag(parent, tail);
889 parents = parents->next;
890 }
891}
892
893static void add_extra_header(struct strbuf *buffer,
894 struct commit_extra_header *extra)
895{
896 strbuf_addstr(buffer, extra->key);
897 strbuf_add_lines(buffer, " ", extra->value, extra->len);
898}
899
900void free_commit_extra_headers(struct commit_extra_header *extra)
901{
902 while (extra) {
903 struct commit_extra_header *next = extra->next;
904 free(extra->key);
905 free(extra->value);
906 free(extra);
907 extra = next;
908 }
909}
910
911int commit_tree(const char *msg, unsigned char *tree,
912 struct commit_list *parents, unsigned char *ret,
913 const char *author)
914{
915 struct commit_extra_header *extra = NULL, **tail = &extra;
916 int result;
917
918 append_merge_tag_headers(parents, &tail);
919 result = commit_tree_extended(msg, tree, parents, ret, author, extra);
920 free_commit_extra_headers(extra);
921 return result;
922}
923
40d52ff7
JK
924static const char commit_utf8_warn[] =
925"Warning: commit message does not conform to UTF-8.\n"
926"You may want to amend it after fixing the message, or set the config\n"
927"variable i18n.commitencoding to the encoding your project uses.\n";
928
5231c633
JH
929int commit_tree_extended(const char *msg, unsigned char *tree,
930 struct commit_list *parents, unsigned char *ret,
931 const char *author, struct commit_extra_header *extra)
40d52ff7
JK
932{
933 int result;
934 int encoding_is_utf8;
935 struct strbuf buffer;
936
937 assert_sha1_type(tree, OBJ_TREE);
938
939 /* Not having i18n.commitencoding is the same as having utf-8 */
940 encoding_is_utf8 = is_encoding_utf8(git_commit_encoding);
941
942 strbuf_init(&buffer, 8192); /* should avoid reallocs for the headers */
943 strbuf_addf(&buffer, "tree %s\n", sha1_to_hex(tree));
944
945 /*
946 * NOTE! This ordering means that the same exact tree merged with a
947 * different order of parents will be a _different_ changeset even
948 * if everything else stays the same.
949 */
950 while (parents) {
951 struct commit_list *next = parents->next;
5231c633
JH
952 struct commit *parent = parents->item;
953
40d52ff7 954 strbuf_addf(&buffer, "parent %s\n",
5231c633 955 sha1_to_hex(parent->object.sha1));
40d52ff7
JK
956 free(parents);
957 parents = next;
958 }
959
960 /* Person/date information */
961 if (!author)
962 author = git_author_info(IDENT_ERROR_ON_NO_NAME);
963 strbuf_addf(&buffer, "author %s\n", author);
964 strbuf_addf(&buffer, "committer %s\n", git_committer_info(IDENT_ERROR_ON_NO_NAME));
965 if (!encoding_is_utf8)
966 strbuf_addf(&buffer, "encoding %s\n", git_commit_encoding);
5231c633
JH
967
968 while (extra) {
969 add_extra_header(&buffer, extra);
970 extra = extra->next;
971 }
40d52ff7
JK
972 strbuf_addch(&buffer, '\n');
973
974 /* And add the comment */
975 strbuf_addstr(&buffer, msg);
976
977 /* And check the encoding */
978 if (encoding_is_utf8 && !is_utf8(buffer.buf))
979 fprintf(stderr, commit_utf8_warn);
980
981 result = write_sha1_file(buffer.buf, buffer.len, commit_type, ret);
982 strbuf_release(&buffer);
983 return result;
984}
ae8e4c9c
JH
985
986struct commit *get_merge_parent(const char *name)
987{
988 struct object *obj;
989 struct commit *commit;
990 unsigned char sha1[20];
991 if (get_sha1(name, sha1))
992 return NULL;
993 obj = parse_object(sha1);
994 commit = (struct commit *)peel_to_type(name, 0, obj, OBJ_COMMIT);
995 if (commit && !commit->util) {
996 struct merge_remote_desc *desc;
997 desc = xmalloc(sizeof(*desc));
998 desc->obj = obj;
999 desc->name = strdup(name);
1000 commit->util = desc;
1001 }
1002 return commit;
1003}