7 int save_commit_buffer
= 1;
12 * the number of children of the associated commit
13 * that also occur in the list being sorted.
15 unsigned int indegree
;
18 * reference to original list item that we will re-use
21 struct commit_list
* list_item
;
25 const char *commit_type
= "commit";
32 { "raw", 1, CMIT_FMT_RAW
},
33 { "medium", 1, CMIT_FMT_MEDIUM
},
34 { "short", 1, CMIT_FMT_SHORT
},
35 { "email", 1, CMIT_FMT_EMAIL
},
36 { "full", 5, CMIT_FMT_FULL
},
37 { "fuller", 5, CMIT_FMT_FULLER
},
38 { "oneline", 1, CMIT_FMT_ONELINE
},
41 enum cmit_fmt
get_commit_format(const char *arg
)
46 return CMIT_FMT_DEFAULT
;
49 for (i
= 0; i
< ARRAY_SIZE(cmt_fmts
); i
++) {
50 if (!strncmp(arg
, cmt_fmts
[i
].n
, cmt_fmts
[i
].cmp_len
))
54 die("invalid --pretty format: %s", arg
);
57 static struct commit
*check_commit(struct object
*obj
,
58 const unsigned char *sha1
,
61 if (obj
->type
!= OBJ_COMMIT
) {
63 error("Object %s is a %s, not a commit",
64 sha1_to_hex(sha1
), typename(obj
->type
));
67 return (struct commit
*) obj
;
70 struct commit
*lookup_commit_reference_gently(const unsigned char *sha1
,
73 struct object
*obj
= deref_tag(parse_object(sha1
), NULL
, 0);
77 return check_commit(obj
, sha1
, quiet
);
80 struct commit
*lookup_commit_reference(const unsigned char *sha1
)
82 return lookup_commit_reference_gently(sha1
, 0);
85 struct commit
*lookup_commit(const unsigned char *sha1
)
87 struct object
*obj
= lookup_object(sha1
);
89 struct commit
*ret
= alloc_commit_node();
90 created_object(sha1
, &ret
->object
);
91 ret
->object
.type
= OBJ_COMMIT
;
95 obj
->type
= OBJ_COMMIT
;
96 return check_commit(obj
, sha1
, 0);
99 static unsigned long parse_commit_date(const char *buf
)
103 if (memcmp(buf
, "author", 6))
105 while (*buf
++ != '\n')
107 if (memcmp(buf
, "committer", 9))
109 while (*buf
++ != '>')
111 date
= strtoul(buf
, NULL
, 10);
112 if (date
== ULONG_MAX
)
117 static struct commit_graft
**commit_graft
;
118 static int commit_graft_alloc
, commit_graft_nr
;
120 static int commit_graft_pos(const unsigned char *sha1
)
124 hi
= commit_graft_nr
;
126 int mi
= (lo
+ hi
) / 2;
127 struct commit_graft
*graft
= commit_graft
[mi
];
128 int cmp
= hashcmp(sha1
, graft
->sha1
);
139 int register_commit_graft(struct commit_graft
*graft
, int ignore_dups
)
141 int pos
= commit_graft_pos(graft
->sha1
);
147 free(commit_graft
[pos
]);
148 commit_graft
[pos
] = graft
;
153 if (commit_graft_alloc
<= ++commit_graft_nr
) {
154 commit_graft_alloc
= alloc_nr(commit_graft_alloc
);
155 commit_graft
= xrealloc(commit_graft
,
156 sizeof(*commit_graft
) *
159 if (pos
< commit_graft_nr
)
160 memmove(commit_graft
+ pos
+ 1,
162 (commit_graft_nr
- pos
- 1) *
163 sizeof(*commit_graft
));
164 commit_graft
[pos
] = graft
;
168 struct commit_graft
*read_graft_line(char *buf
, int len
)
170 /* The format is just "Commit Parent1 Parent2 ...\n" */
172 struct commit_graft
*graft
= NULL
;
174 if (buf
[len
-1] == '\n')
176 if (buf
[0] == '#' || buf
[0] == '\0')
178 if ((len
+ 1) % 41) {
180 error("bad graft data: %s", buf
);
184 i
= (len
+ 1) / 41 - 1;
185 graft
= xmalloc(sizeof(*graft
) + 20 * i
);
186 graft
->nr_parent
= i
;
187 if (get_sha1_hex(buf
, graft
->sha1
))
189 for (i
= 40; i
< len
; i
+= 41) {
192 if (get_sha1_hex(buf
+ i
+ 1, graft
->parent
[i
/41]))
198 int read_graft_file(const char *graft_file
)
200 FILE *fp
= fopen(graft_file
, "r");
204 while (fgets(buf
, sizeof(buf
), fp
)) {
205 /* The format is just "Commit Parent1 Parent2 ...\n" */
206 int len
= strlen(buf
);
207 struct commit_graft
*graft
= read_graft_line(buf
, len
);
210 if (register_commit_graft(graft
, 1))
211 error("duplicate graft data: %s", buf
);
217 static void prepare_commit_graft(void)
219 static int commit_graft_prepared
;
222 if (commit_graft_prepared
)
224 graft_file
= get_graft_file();
225 read_graft_file(graft_file
);
226 /* make sure shallows are read */
227 is_repository_shallow();
228 commit_graft_prepared
= 1;
231 static struct commit_graft
*lookup_commit_graft(const unsigned char *sha1
)
234 prepare_commit_graft();
235 pos
= commit_graft_pos(sha1
);
238 return commit_graft
[pos
];
241 int write_shallow_commits(int fd
, int use_pack_protocol
)
244 for (i
= 0; i
< commit_graft_nr
; i
++)
245 if (commit_graft
[i
]->nr_parent
< 0) {
247 sha1_to_hex(commit_graft
[i
]->sha1
);
249 if (use_pack_protocol
)
250 packet_write(fd
, "shallow %s", hex
);
252 if (write_in_full(fd
, hex
, 40) != 40)
254 if (write_in_full(fd
, "\n", 1) != 1)
261 int unregister_shallow(const unsigned char *sha1
)
263 int pos
= commit_graft_pos(sha1
);
266 if (pos
+ 1 < commit_graft_nr
)
267 memcpy(commit_graft
+ pos
, commit_graft
+ pos
+ 1,
268 sizeof(struct commit_graft
*)
269 * (commit_graft_nr
- pos
- 1));
274 int parse_commit_buffer(struct commit
*item
, void *buffer
, unsigned long size
)
277 char *bufptr
= buffer
;
278 unsigned char parent
[20];
279 struct commit_list
**pptr
;
280 struct commit_graft
*graft
;
283 if (item
->object
.parsed
)
285 item
->object
.parsed
= 1;
287 if (tail
<= bufptr
+ 5 || memcmp(bufptr
, "tree ", 5))
288 return error("bogus commit object %s", sha1_to_hex(item
->object
.sha1
));
289 if (tail
<= bufptr
+ 45 || get_sha1_hex(bufptr
+ 5, parent
) < 0)
290 return error("bad tree pointer in commit %s",
291 sha1_to_hex(item
->object
.sha1
));
292 item
->tree
= lookup_tree(parent
);
295 bufptr
+= 46; /* "tree " + "hex sha1" + "\n" */
296 pptr
= &item
->parents
;
298 graft
= lookup_commit_graft(item
->object
.sha1
);
299 while (bufptr
+ 48 < tail
&& !memcmp(bufptr
, "parent ", 7)) {
300 struct commit
*new_parent
;
302 if (tail
<= bufptr
+ 48 ||
303 get_sha1_hex(bufptr
+ 7, parent
) ||
305 return error("bad parents in commit %s", sha1_to_hex(item
->object
.sha1
));
309 new_parent
= lookup_commit(parent
);
311 pptr
= &commit_list_insert(new_parent
, pptr
)->next
;
317 struct commit
*new_parent
;
318 for (i
= 0; i
< graft
->nr_parent
; i
++) {
319 new_parent
= lookup_commit(graft
->parent
[i
]);
322 pptr
= &commit_list_insert(new_parent
, pptr
)->next
;
326 item
->date
= parse_commit_date(bufptr
);
328 if (track_object_refs
) {
330 struct commit_list
*p
;
331 struct object_refs
*refs
= alloc_object_refs(n_refs
);
333 refs
->ref
[i
++] = &item
->tree
->object
;
334 for (p
= item
->parents
; p
; p
= p
->next
)
335 refs
->ref
[i
++] = &p
->item
->object
;
336 set_object_refs(&item
->object
, refs
);
342 int parse_commit(struct commit
*item
)
349 if (item
->object
.parsed
)
351 buffer
= read_sha1_file(item
->object
.sha1
, type
, &size
);
353 return error("Could not read %s",
354 sha1_to_hex(item
->object
.sha1
));
355 if (strcmp(type
, commit_type
)) {
357 return error("Object %s not a commit",
358 sha1_to_hex(item
->object
.sha1
));
360 ret
= parse_commit_buffer(item
, buffer
, size
);
361 if (save_commit_buffer
&& !ret
) {
362 item
->buffer
= buffer
;
369 struct commit_list
*commit_list_insert(struct commit
*item
, struct commit_list
**list_p
)
371 struct commit_list
*new_list
= xmalloc(sizeof(struct commit_list
));
372 new_list
->item
= item
;
373 new_list
->next
= *list_p
;
378 void free_commit_list(struct commit_list
*list
)
381 struct commit_list
*temp
= list
;
387 struct commit_list
* insert_by_date(struct commit
*item
, struct commit_list
**list
)
389 struct commit_list
**pp
= list
;
390 struct commit_list
*p
;
391 while ((p
= *pp
) != NULL
) {
392 if (p
->item
->date
< item
->date
) {
397 return commit_list_insert(item
, pp
);
401 void sort_by_date(struct commit_list
**list
)
403 struct commit_list
*ret
= NULL
;
405 insert_by_date((*list
)->item
, &ret
);
406 *list
= (*list
)->next
;
411 struct commit
*pop_most_recent_commit(struct commit_list
**list
,
414 struct commit
*ret
= (*list
)->item
;
415 struct commit_list
*parents
= ret
->parents
;
416 struct commit_list
*old
= *list
;
418 *list
= (*list
)->next
;
422 struct commit
*commit
= parents
->item
;
423 parse_commit(commit
);
424 if (!(commit
->object
.flags
& mark
)) {
425 commit
->object
.flags
|= mark
;
426 insert_by_date(commit
, list
);
428 parents
= parents
->next
;
433 void clear_commit_marks(struct commit
*commit
, unsigned int mark
)
435 struct commit_list
*parents
;
437 commit
->object
.flags
&= ~mark
;
438 parents
= commit
->parents
;
440 struct commit
*parent
= parents
->item
;
442 /* Have we already cleared this? */
443 if (mark
& parent
->object
.flags
)
444 clear_commit_marks(parent
, mark
);
445 parents
= parents
->next
;
450 * Generic support for pretty-printing the header
452 static int get_one_line(const char *msg
, unsigned long len
)
467 /* High bit set, or ISO-2022-INT */
468 static int non_ascii(int ch
)
471 return ((ch
& 0x80) || (ch
== 0x1b));
474 static int is_rfc2047_special(char ch
)
476 return (non_ascii(ch
) || (ch
== '=') || (ch
== '?') || (ch
== '_'));
479 static int add_rfc2047(char *buf
, const char *line
, int len
,
480 const char *encoding
)
484 char q_encoding
[128];
485 const char *q_encoding_fmt
= "=?%s?q?";
487 for (i
= needquote
= 0; !needquote
&& i
< len
; i
++) {
492 (ch
== '=' && line
[i
+1] == '?'))
496 return sprintf(buf
, "%.*s", len
, line
);
498 i
= snprintf(q_encoding
, sizeof(q_encoding
), q_encoding_fmt
, encoding
);
499 if (sizeof(q_encoding
) < i
)
500 die("Insanely long encoding name %s", encoding
);
501 memcpy(bp
, q_encoding
, i
);
503 for (i
= 0; i
< len
; i
++) {
504 unsigned ch
= line
[i
] & 0xFF;
505 if (is_rfc2047_special(ch
)) {
506 sprintf(bp
, "=%02X", ch
);
519 static int add_user_info(const char *what
, enum cmit_fmt fmt
, char *buf
,
520 const char *line
, int relative_date
,
521 const char *encoding
)
527 const char *filler
= " ";
529 if (fmt
== CMIT_FMT_ONELINE
)
531 date
= strchr(line
, '>');
534 namelen
= ++date
- line
;
535 time
= strtoul(date
, &date
, 10);
536 tz
= strtol(date
, NULL
, 10);
538 if (fmt
== CMIT_FMT_EMAIL
) {
539 char *name_tail
= strchr(line
, '<');
540 int display_name_length
;
543 while (line
< name_tail
&& isspace(name_tail
[-1]))
545 display_name_length
= name_tail
- line
;
547 strcpy(buf
, "From: ");
549 ret
+= add_rfc2047(buf
+ ret
, line
, display_name_length
,
551 memcpy(buf
+ ret
, name_tail
, namelen
- display_name_length
);
552 ret
+= namelen
- display_name_length
;
556 ret
= sprintf(buf
, "%s: %.*s%.*s\n", what
,
557 (fmt
== CMIT_FMT_FULLER
) ? 4 : 0,
558 filler
, namelen
, line
);
561 case CMIT_FMT_MEDIUM
:
562 ret
+= sprintf(buf
+ ret
, "Date: %s\n",
563 show_date(time
, tz
, relative_date
));
566 ret
+= sprintf(buf
+ ret
, "Date: %s\n",
567 show_rfc2822_date(time
, tz
));
569 case CMIT_FMT_FULLER
:
570 ret
+= sprintf(buf
+ ret
, "%sDate: %s\n", what
,
571 show_date(time
, tz
, relative_date
));
580 static int is_empty_line(const char *line
, int *len_p
)
583 while (len
&& isspace(line
[len
-1]))
589 static int add_merge_info(enum cmit_fmt fmt
, char *buf
, const struct commit
*commit
, int abbrev
)
591 struct commit_list
*parent
= commit
->parents
;
594 if ((fmt
== CMIT_FMT_ONELINE
) || (fmt
== CMIT_FMT_EMAIL
) ||
595 !parent
|| !parent
->next
)
598 offset
= sprintf(buf
, "Merge:");
601 struct commit
*p
= parent
->item
;
602 const char *hex
= NULL
;
605 hex
= find_unique_abbrev(p
->object
.sha1
, abbrev
);
607 hex
= sha1_to_hex(p
->object
.sha1
);
608 dots
= (abbrev
&& strlen(hex
) != 40) ? "..." : "";
609 parent
= parent
->next
;
611 offset
+= sprintf(buf
+ offset
, " %s%s", hex
, dots
);
613 buf
[offset
++] = '\n';
617 static char *get_header(const struct commit
*commit
, const char *key
)
619 int key_len
= strlen(key
);
620 const char *line
= commit
->buffer
;
623 const char *eol
= strchr(line
, '\n'), *next
;
628 eol
= line
+ strlen(line
);
632 if (!strncmp(line
, key
, key_len
) && line
[key_len
] == ' ') {
633 int len
= eol
- line
- key_len
;
634 char *ret
= xmalloc(len
);
635 memcpy(ret
, line
+ key_len
+ 1, len
- 1);
643 static char *replace_encoding_header(char *buf
, char *encoding
)
645 char *encoding_header
= strstr(buf
, "\nencoding ");
646 char *end_of_encoding_header
;
647 int encoding_header_pos
;
648 int encoding_header_len
;
651 int buflen
= strlen(buf
) + 1;
653 if (!encoding_header
)
654 return buf
; /* should not happen but be defensive */
656 end_of_encoding_header
= strchr(encoding_header
, '\n');
657 if (!end_of_encoding_header
)
658 return buf
; /* should not happen but be defensive */
659 end_of_encoding_header
++;
661 encoding_header_len
= end_of_encoding_header
- encoding_header
;
662 encoding_header_pos
= encoding_header
- buf
;
664 if (is_encoding_utf8(encoding
)) {
665 /* we have re-coded to UTF-8; drop the header */
666 memmove(encoding_header
, end_of_encoding_header
,
667 buflen
- (encoding_header_pos
+ encoding_header_len
));
670 new_len
= strlen(encoding
);
671 need_len
= new_len
+ strlen("encoding \n");
672 if (encoding_header_len
< need_len
) {
673 buf
= xrealloc(buf
, buflen
+ (need_len
- encoding_header_len
));
674 encoding_header
= buf
+ encoding_header_pos
;
675 end_of_encoding_header
= encoding_header
+ encoding_header_len
;
677 memmove(end_of_encoding_header
+ (need_len
- encoding_header_len
),
678 end_of_encoding_header
,
679 buflen
- (encoding_header_pos
+ encoding_header_len
));
680 memcpy(encoding_header
+ 9, encoding
, strlen(encoding
));
681 encoding_header
[9 + new_len
] = '\n';
685 static char *logmsg_reencode(const struct commit
*commit
,
686 char *output_encoding
)
690 char *utf8
= "utf-8";
692 if (!*output_encoding
)
694 encoding
= get_header(commit
, "encoding");
697 if (!strcmp(encoding
, output_encoding
))
698 out
= strdup(commit
->buffer
);
700 out
= reencode_string(commit
->buffer
,
701 output_encoding
, encoding
);
703 out
= replace_encoding_header(out
, output_encoding
);
705 if (encoding
!= utf8
)
712 unsigned long pretty_print_commit(enum cmit_fmt fmt
,
713 const struct commit
*commit
,
715 char *buf
, unsigned long space
,
716 int abbrev
, const char *subject
,
717 const char *after_subject
,
720 int hdr
= 1, body
= 0, seen_title
= 0;
721 unsigned long offset
= 0;
723 int parents_shown
= 0;
724 const char *msg
= commit
->buffer
;
725 int plain_non_ascii
= 0;
729 encoding
= (git_log_output_encoding
730 ? git_log_output_encoding
731 : git_commit_encoding
);
734 reencoded
= logmsg_reencode(commit
, encoding
);
738 if (fmt
== CMIT_FMT_ONELINE
|| fmt
== CMIT_FMT_EMAIL
)
741 /* After-subject is used to pass in Content-Type: multipart
742 * MIME header; in that case we do not have to do the
743 * plaintext content type even if the commit message has
744 * non 7-bit ASCII character. Otherwise, check if we need
745 * to say this is not a 7-bit ASCII.
747 if (fmt
== CMIT_FMT_EMAIL
&& !after_subject
) {
750 for (in_body
= i
= 0; (ch
= msg
[i
]) && i
< len
; i
++) {
752 /* author could be non 7-bit ASCII but
753 * the log may be so; skip over the
757 i
+ 1 < len
&& msg
[i
+1] == '\n')
760 else if (non_ascii(ch
)) {
768 const char *line
= msg
;
769 int linelen
= get_one_line(msg
, len
);
775 * We want some slop for indentation and a possible
776 * final "...". Thus the "+ 20".
778 if (offset
+ linelen
+ 20 > space
) {
779 memcpy(buf
+ offset
, " ...\n", 8);
789 if ((fmt
!= CMIT_FMT_ONELINE
) && !subject
)
790 buf
[offset
++] = '\n';
793 if (fmt
== CMIT_FMT_RAW
) {
794 memcpy(buf
+ offset
, line
, linelen
);
798 if (!memcmp(line
, "parent ", 7)) {
800 die("bad parent line in commit");
804 if (!parents_shown
) {
805 offset
+= add_merge_info(fmt
, buf
+ offset
,
811 * MEDIUM == DEFAULT shows only author with dates.
812 * FULL shows both authors but not dates.
813 * FULLER shows both authors and dates.
815 if (!memcmp(line
, "author ", 7))
816 offset
+= add_user_info("Author", fmt
,
821 if (!memcmp(line
, "committer ", 10) &&
822 (fmt
== CMIT_FMT_FULL
|| fmt
== CMIT_FMT_FULLER
))
823 offset
+= add_user_info("Commit", fmt
,
834 if (is_empty_line(line
, &linelen
)) {
841 if (fmt
== CMIT_FMT_SHORT
)
847 int slen
= strlen(subject
);
848 memcpy(buf
+ offset
, subject
, slen
);
850 offset
+= add_rfc2047(buf
+ offset
, line
, linelen
,
854 memset(buf
+ offset
, ' ', indent
);
855 memcpy(buf
+ offset
+ indent
, line
, linelen
);
856 offset
+= linelen
+ indent
;
858 buf
[offset
++] = '\n';
859 if (fmt
== CMIT_FMT_ONELINE
)
861 if (subject
&& plain_non_ascii
) {
864 const char *header_fmt
=
865 "Content-Type: text/plain; charset=%s\n"
866 "Content-Transfer-Encoding: 8bit\n";
867 sz
= snprintf(header
, sizeof(header
), header_fmt
,
869 if (sizeof(header
) < sz
)
870 die("Encoding name %s too long", encoding
);
871 memcpy(buf
+ offset
, header
, sz
);
875 int slen
= strlen(after_subject
);
876 if (slen
> space
- offset
- 1)
877 slen
= space
- offset
- 1;
878 memcpy(buf
+ offset
, after_subject
, slen
);
880 after_subject
= NULL
;
884 while (offset
&& isspace(buf
[offset
-1]))
886 /* Make sure there is an EOLN for the non-oneline case */
887 if (fmt
!= CMIT_FMT_ONELINE
)
888 buf
[offset
++] = '\n';
890 * make sure there is another EOLN to separate the headers from whatever
891 * body the caller appends if we haven't already written a body
893 if (fmt
== CMIT_FMT_EMAIL
&& !body
)
894 buf
[offset
++] = '\n';
901 struct commit
*pop_commit(struct commit_list
**stack
)
903 struct commit_list
*top
= *stack
;
904 struct commit
*item
= top
? top
->item
: NULL
;
913 int count_parents(struct commit
* commit
)
916 struct commit_list
* parents
= commit
->parents
;
917 for (count
= 0; parents
; parents
= parents
->next
,count
++)
922 void topo_sort_default_setter(struct commit
*c
, void *data
)
927 void *topo_sort_default_getter(struct commit
*c
)
933 * Performs an in-place topological sort on the list supplied.
935 void sort_in_topological_order(struct commit_list
** list
, int lifo
)
937 sort_in_topological_order_fn(list
, lifo
, topo_sort_default_setter
,
938 topo_sort_default_getter
);
941 void sort_in_topological_order_fn(struct commit_list
** list
, int lifo
,
942 topo_sort_set_fn_t setter
,
943 topo_sort_get_fn_t getter
)
945 struct commit_list
* next
= *list
;
946 struct commit_list
* work
= NULL
, **insert
;
947 struct commit_list
** pptr
= list
;
948 struct sort_node
* nodes
;
949 struct sort_node
* next_nodes
;
952 /* determine the size of the list */
960 /* allocate an array to help sort the list */
961 nodes
= xcalloc(count
, sizeof(*nodes
));
962 /* link the list to the array */
966 next_nodes
->list_item
= next
;
967 setter(next
->item
, next_nodes
);
971 /* update the indegree */
974 struct commit_list
* parents
= next
->item
->parents
;
976 struct commit
* parent
=parents
->item
;
977 struct sort_node
* pn
= (struct sort_node
*) getter(parent
);
981 parents
=parents
->next
;
988 * tips are nodes not reachable from any other node in the list
990 * the tips serve as a starting set for the work queue.
995 struct sort_node
* node
= (struct sort_node
*) getter(next
->item
);
997 if (node
->indegree
== 0) {
998 insert
= &commit_list_insert(next
->item
, insert
)->next
;
1003 /* process the list in topological order */
1005 sort_by_date(&work
);
1007 struct commit
* work_item
= pop_commit(&work
);
1008 struct sort_node
* work_node
= (struct sort_node
*) getter(work_item
);
1009 struct commit_list
* parents
= work_item
->parents
;
1012 struct commit
* parent
=parents
->item
;
1013 struct sort_node
* pn
= (struct sort_node
*) getter(parent
);
1017 * parents are only enqueued for emission
1018 * when all their children have been emitted thereby
1019 * guaranteeing topological order.
1022 if (!pn
->indegree
) {
1024 insert_by_date(parent
, &work
);
1026 commit_list_insert(parent
, &work
);
1029 parents
=parents
->next
;
1032 * work_item is a commit all of whose children
1033 * have already been emitted. we can emit it now.
1035 *pptr
= work_node
->list_item
;
1036 pptr
= &(*pptr
)->next
;
1038 setter(work_item
, NULL
);
1043 /* merge-base stuff */
1045 /* bits #0..15 in revision.h */
1046 #define PARENT1 (1u<<16)
1047 #define PARENT2 (1u<<17)
1048 #define STALE (1u<<18)
1049 #define RESULT (1u<<19)
1051 static const unsigned all_flags
= (PARENT1
| PARENT2
| STALE
| RESULT
);
1053 static struct commit
*interesting(struct commit_list
*list
)
1056 struct commit
*commit
= list
->item
;
1058 if (commit
->object
.flags
& STALE
)
1065 static struct commit_list
*merge_bases(struct commit
*one
, struct commit
*two
)
1067 struct commit_list
*list
= NULL
;
1068 struct commit_list
*result
= NULL
;
1071 /* We do not mark this even with RESULT so we do not
1072 * have to clean it up.
1074 return commit_list_insert(one
, &result
);
1079 one
->object
.flags
|= PARENT1
;
1080 two
->object
.flags
|= PARENT2
;
1081 insert_by_date(one
, &list
);
1082 insert_by_date(two
, &list
);
1084 while (interesting(list
)) {
1085 struct commit
*commit
;
1086 struct commit_list
*parents
;
1087 struct commit_list
*n
;
1090 commit
= list
->item
;
1095 flags
= commit
->object
.flags
& (PARENT1
| PARENT2
| STALE
);
1096 if (flags
== (PARENT1
| PARENT2
)) {
1097 if (!(commit
->object
.flags
& RESULT
)) {
1098 commit
->object
.flags
|= RESULT
;
1099 insert_by_date(commit
, &result
);
1101 /* Mark parents of a found merge stale */
1104 parents
= commit
->parents
;
1106 struct commit
*p
= parents
->item
;
1107 parents
= parents
->next
;
1108 if ((p
->object
.flags
& flags
) == flags
)
1111 p
->object
.flags
|= flags
;
1112 insert_by_date(p
, &list
);
1116 /* Clean up the result to remove stale ones */
1117 free_commit_list(list
);
1118 list
= result
; result
= NULL
;
1120 struct commit_list
*n
= list
->next
;
1121 if (!(list
->item
->object
.flags
& STALE
))
1122 insert_by_date(list
->item
, &result
);
1129 struct commit_list
*get_merge_bases(struct commit
*one
,
1133 struct commit_list
*list
;
1134 struct commit
**rslt
;
1135 struct commit_list
*result
;
1138 result
= merge_bases(one
, two
);
1141 if (!result
|| !result
->next
) {
1143 clear_commit_marks(one
, all_flags
);
1144 clear_commit_marks(two
, all_flags
);
1149 /* There are more than one */
1156 rslt
= xcalloc(cnt
, sizeof(*rslt
));
1157 for (list
= result
, i
= 0; list
; list
= list
->next
)
1158 rslt
[i
++] = list
->item
;
1159 free_commit_list(result
);
1161 clear_commit_marks(one
, all_flags
);
1162 clear_commit_marks(two
, all_flags
);
1163 for (i
= 0; i
< cnt
- 1; i
++) {
1164 for (j
= i
+1; j
< cnt
; j
++) {
1165 if (!rslt
[i
] || !rslt
[j
])
1167 result
= merge_bases(rslt
[i
], rslt
[j
]);
1168 clear_commit_marks(rslt
[i
], all_flags
);
1169 clear_commit_marks(rslt
[j
], all_flags
);
1170 for (list
= result
; list
; list
= list
->next
) {
1171 if (rslt
[i
] == list
->item
)
1173 if (rslt
[j
] == list
->item
)
1179 /* Surviving ones in rslt[] are the independent results */
1181 for (i
= 0; i
< cnt
; i
++) {
1183 insert_by_date(rslt
[i
], &result
);
1189 int in_merge_bases(struct commit
*rev1
, struct commit
*rev2
)
1191 struct commit_list
*bases
, *b
;
1194 bases
= get_merge_bases(rev1
, rev2
, 1);
1195 for (b
= bases
; b
; b
= b
->next
) {
1196 if (!hashcmp(rev1
->object
.sha1
, b
->item
->object
.sha1
)) {
1202 free_commit_list(bases
);