5 int save_commit_buffer
= 1;
10 * the number of children of the associated commit
11 * that also occur in the list being sorted.
13 unsigned int indegree
;
16 * reference to original list item that we will re-use
19 struct commit_list
* list_item
;
23 const char *commit_type
= "commit";
30 { "raw", 1, CMIT_FMT_RAW
},
31 { "medium", 1, CMIT_FMT_MEDIUM
},
32 { "short", 1, CMIT_FMT_SHORT
},
33 { "email", 1, CMIT_FMT_EMAIL
},
34 { "full", 5, CMIT_FMT_FULL
},
35 { "fuller", 5, CMIT_FMT_FULLER
},
36 { "oneline", 1, CMIT_FMT_ONELINE
},
39 enum cmit_fmt
get_commit_format(const char *arg
)
44 return CMIT_FMT_DEFAULT
;
47 for (i
= 0; i
< ARRAY_SIZE(cmt_fmts
); i
++) {
48 if (!strncmp(arg
, cmt_fmts
[i
].n
, cmt_fmts
[i
].cmp_len
))
52 die("invalid --pretty format: %s", arg
);
55 static struct commit
*check_commit(struct object
*obj
,
56 const unsigned char *sha1
,
59 if (obj
->type
!= TYPE_COMMIT
) {
61 error("Object %s is a %s, not a commit",
62 sha1_to_hex(sha1
), typename(obj
->type
));
65 return (struct commit
*) obj
;
68 struct commit
*lookup_commit_reference_gently(const unsigned char *sha1
,
71 struct object
*obj
= deref_tag(parse_object(sha1
), NULL
, 0);
75 return check_commit(obj
, sha1
, quiet
);
78 struct commit
*lookup_commit_reference(const unsigned char *sha1
)
80 return lookup_commit_reference_gently(sha1
, 0);
83 struct commit
*lookup_commit(const unsigned char *sha1
)
85 struct object
*obj
= lookup_object(sha1
);
87 struct commit
*ret
= alloc_commit_node();
88 created_object(sha1
, &ret
->object
);
89 ret
->object
.type
= TYPE_COMMIT
;
93 obj
->type
= TYPE_COMMIT
;
94 return check_commit(obj
, sha1
, 0);
97 static unsigned long parse_commit_date(const char *buf
)
101 if (memcmp(buf
, "author", 6))
103 while (*buf
++ != '\n')
105 if (memcmp(buf
, "committer", 9))
107 while (*buf
++ != '>')
109 date
= strtoul(buf
, NULL
, 10);
110 if (date
== ULONG_MAX
)
115 static struct commit_graft
**commit_graft
;
116 static int commit_graft_alloc
, commit_graft_nr
;
118 static int commit_graft_pos(const unsigned char *sha1
)
122 hi
= commit_graft_nr
;
124 int mi
= (lo
+ hi
) / 2;
125 struct commit_graft
*graft
= commit_graft
[mi
];
126 int cmp
= memcmp(sha1
, graft
->sha1
, 20);
137 int register_commit_graft(struct commit_graft
*graft
, int ignore_dups
)
139 int pos
= commit_graft_pos(graft
->sha1
);
145 free(commit_graft
[pos
]);
146 commit_graft
[pos
] = graft
;
151 if (commit_graft_alloc
<= ++commit_graft_nr
) {
152 commit_graft_alloc
= alloc_nr(commit_graft_alloc
);
153 commit_graft
= xrealloc(commit_graft
,
154 sizeof(*commit_graft
) *
157 if (pos
< commit_graft_nr
)
158 memmove(commit_graft
+ pos
+ 1,
160 (commit_graft_nr
- pos
- 1) *
161 sizeof(*commit_graft
));
162 commit_graft
[pos
] = graft
;
166 struct commit_graft
*read_graft_line(char *buf
, int len
)
168 /* The format is just "Commit Parent1 Parent2 ...\n" */
170 struct commit_graft
*graft
= NULL
;
172 if (buf
[len
-1] == '\n')
174 if (buf
[0] == '#' || buf
[0] == '\0')
176 if ((len
+ 1) % 41) {
178 error("bad graft data: %s", buf
);
182 i
= (len
+ 1) / 41 - 1;
183 graft
= xmalloc(sizeof(*graft
) + 20 * i
);
184 graft
->nr_parent
= i
;
185 if (get_sha1_hex(buf
, graft
->sha1
))
187 for (i
= 40; i
< len
; i
+= 41) {
190 if (get_sha1_hex(buf
+ i
+ 1, graft
->parent
[i
/41]))
196 int read_graft_file(const char *graft_file
)
198 FILE *fp
= fopen(graft_file
, "r");
202 while (fgets(buf
, sizeof(buf
), fp
)) {
203 /* The format is just "Commit Parent1 Parent2 ...\n" */
204 int len
= strlen(buf
);
205 struct commit_graft
*graft
= read_graft_line(buf
, len
);
208 if (register_commit_graft(graft
, 1))
209 error("duplicate graft data: %s", buf
);
215 static void prepare_commit_graft(void)
217 static int commit_graft_prepared
;
220 if (commit_graft_prepared
)
222 graft_file
= get_graft_file();
223 read_graft_file(graft_file
);
224 commit_graft_prepared
= 1;
227 static struct commit_graft
*lookup_commit_graft(const unsigned char *sha1
)
230 prepare_commit_graft();
231 pos
= commit_graft_pos(sha1
);
234 return commit_graft
[pos
];
237 int parse_commit_buffer(struct commit
*item
, void *buffer
, unsigned long size
)
240 char *bufptr
= buffer
;
241 unsigned char parent
[20];
242 struct commit_list
**pptr
;
243 struct commit_graft
*graft
;
246 if (item
->object
.parsed
)
248 item
->object
.parsed
= 1;
250 if (tail
<= bufptr
+ 5 || memcmp(bufptr
, "tree ", 5))
251 return error("bogus commit object %s", sha1_to_hex(item
->object
.sha1
));
252 if (tail
<= bufptr
+ 45 || get_sha1_hex(bufptr
+ 5, parent
) < 0)
253 return error("bad tree pointer in commit %s",
254 sha1_to_hex(item
->object
.sha1
));
255 item
->tree
= lookup_tree(parent
);
258 bufptr
+= 46; /* "tree " + "hex sha1" + "\n" */
259 pptr
= &item
->parents
;
261 graft
= lookup_commit_graft(item
->object
.sha1
);
262 while (bufptr
+ 48 < tail
&& !memcmp(bufptr
, "parent ", 7)) {
263 struct commit
*new_parent
;
265 if (tail
<= bufptr
+ 48 ||
266 get_sha1_hex(bufptr
+ 7, parent
) ||
268 return error("bad parents in commit %s", sha1_to_hex(item
->object
.sha1
));
272 new_parent
= lookup_commit(parent
);
274 pptr
= &commit_list_insert(new_parent
, pptr
)->next
;
280 struct commit
*new_parent
;
281 for (i
= 0; i
< graft
->nr_parent
; i
++) {
282 new_parent
= lookup_commit(graft
->parent
[i
]);
285 pptr
= &commit_list_insert(new_parent
, pptr
)->next
;
289 item
->date
= parse_commit_date(bufptr
);
291 if (track_object_refs
) {
293 struct commit_list
*p
;
294 struct object_refs
*refs
= alloc_object_refs(n_refs
);
296 refs
->ref
[i
++] = &item
->tree
->object
;
297 for (p
= item
->parents
; p
; p
= p
->next
)
298 refs
->ref
[i
++] = &p
->item
->object
;
299 set_object_refs(&item
->object
, refs
);
305 int parse_commit(struct commit
*item
)
312 if (item
->object
.parsed
)
314 buffer
= read_sha1_file(item
->object
.sha1
, type
, &size
);
316 return error("Could not read %s",
317 sha1_to_hex(item
->object
.sha1
));
318 if (strcmp(type
, commit_type
)) {
320 return error("Object %s not a commit",
321 sha1_to_hex(item
->object
.sha1
));
323 ret
= parse_commit_buffer(item
, buffer
, size
);
324 if (save_commit_buffer
&& !ret
) {
325 item
->buffer
= buffer
;
332 struct commit_list
*commit_list_insert(struct commit
*item
, struct commit_list
**list_p
)
334 struct commit_list
*new_list
= xmalloc(sizeof(struct commit_list
));
335 new_list
->item
= item
;
336 new_list
->next
= *list_p
;
341 void free_commit_list(struct commit_list
*list
)
344 struct commit_list
*temp
= list
;
350 struct commit_list
* insert_by_date(struct commit
*item
, struct commit_list
**list
)
352 struct commit_list
**pp
= list
;
353 struct commit_list
*p
;
354 while ((p
= *pp
) != NULL
) {
355 if (p
->item
->date
< item
->date
) {
360 return commit_list_insert(item
, pp
);
364 void sort_by_date(struct commit_list
**list
)
366 struct commit_list
*ret
= NULL
;
368 insert_by_date((*list
)->item
, &ret
);
369 *list
= (*list
)->next
;
374 struct commit
*pop_most_recent_commit(struct commit_list
**list
,
377 struct commit
*ret
= (*list
)->item
;
378 struct commit_list
*parents
= ret
->parents
;
379 struct commit_list
*old
= *list
;
381 *list
= (*list
)->next
;
385 struct commit
*commit
= parents
->item
;
386 parse_commit(commit
);
387 if (!(commit
->object
.flags
& mark
)) {
388 commit
->object
.flags
|= mark
;
389 insert_by_date(commit
, list
);
391 parents
= parents
->next
;
396 void clear_commit_marks(struct commit
*commit
, unsigned int mark
)
398 struct commit_list
*parents
;
402 parents
= commit
->parents
;
403 commit
->object
.flags
&= ~mark
;
405 clear_commit_marks(parents
->item
, mark
);
406 parents
= parents
->next
;
411 * Generic support for pretty-printing the header
413 static int get_one_line(const char *msg
, unsigned long len
)
428 static int is_rfc2047_special(char ch
)
430 return ((ch
& 0x80) || (ch
== '=') || (ch
== '?') || (ch
== '_'));
433 static int add_rfc2047(char *buf
, const char *line
, int len
)
437 static const char q_utf8
[] = "=?utf-8?q?";
439 for (i
= needquote
= 0; !needquote
&& i
< len
; i
++) {
440 unsigned ch
= line
[i
];
444 (ch
== '=' && line
[i
+1] == '?'))
448 return sprintf(buf
, "%.*s", len
, line
);
450 memcpy(bp
, q_utf8
, sizeof(q_utf8
)-1);
451 bp
+= sizeof(q_utf8
)-1;
452 for (i
= 0; i
< len
; i
++) {
453 unsigned ch
= line
[i
] & 0xFF;
454 if (is_rfc2047_special(ch
)) {
455 sprintf(bp
, "=%02X", ch
);
468 static int add_user_info(const char *what
, enum cmit_fmt fmt
, char *buf
, const char *line
)
474 const char *filler
= " ";
476 if (fmt
== CMIT_FMT_ONELINE
)
478 date
= strchr(line
, '>');
481 namelen
= ++date
- line
;
482 time
= strtoul(date
, &date
, 10);
483 tz
= strtol(date
, NULL
, 10);
485 if (fmt
== CMIT_FMT_EMAIL
) {
486 char *name_tail
= strchr(line
, '<');
487 int display_name_length
;
490 while (line
< name_tail
&& isspace(name_tail
[-1]))
492 display_name_length
= name_tail
- line
;
494 strcpy(buf
, "From: ");
496 ret
+= add_rfc2047(buf
+ ret
, line
, display_name_length
);
497 memcpy(buf
+ ret
, name_tail
, namelen
- display_name_length
);
498 ret
+= namelen
- display_name_length
;
502 ret
= sprintf(buf
, "%s: %.*s%.*s\n", what
,
503 (fmt
== CMIT_FMT_FULLER
) ? 4 : 0,
504 filler
, namelen
, line
);
507 case CMIT_FMT_MEDIUM
:
508 ret
+= sprintf(buf
+ ret
, "Date: %s\n", show_date(time
, tz
));
511 ret
+= sprintf(buf
+ ret
, "Date: %s\n",
512 show_rfc2822_date(time
, tz
));
514 case CMIT_FMT_FULLER
:
515 ret
+= sprintf(buf
+ ret
, "%sDate: %s\n", what
, show_date(time
, tz
));
524 static int is_empty_line(const char *line
, int *len_p
)
527 while (len
&& isspace(line
[len
-1]))
533 static int add_merge_info(enum cmit_fmt fmt
, char *buf
, const struct commit
*commit
, int abbrev
)
535 struct commit_list
*parent
= commit
->parents
;
538 if ((fmt
== CMIT_FMT_ONELINE
) || (fmt
== CMIT_FMT_EMAIL
) ||
539 !parent
|| !parent
->next
)
542 offset
= sprintf(buf
, "Merge:");
545 struct commit
*p
= parent
->item
;
546 const char *hex
= abbrev
547 ? find_unique_abbrev(p
->object
.sha1
, abbrev
)
548 : sha1_to_hex(p
->object
.sha1
);
549 const char *dots
= (abbrev
&& strlen(hex
) != 40) ? "..." : "";
550 parent
= parent
->next
;
552 offset
+= sprintf(buf
+ offset
, " %s%s", hex
, dots
);
554 buf
[offset
++] = '\n';
558 unsigned long pretty_print_commit(enum cmit_fmt fmt
, const struct commit
*commit
, unsigned long len
, char *buf
, unsigned long space
, int abbrev
, const char *subject
, const char *after_subject
)
560 int hdr
= 1, body
= 0;
561 unsigned long offset
= 0;
563 int parents_shown
= 0;
564 const char *msg
= commit
->buffer
;
565 int plain_non_ascii
= 0;
567 if (fmt
== CMIT_FMT_ONELINE
|| fmt
== CMIT_FMT_EMAIL
)
570 /* After-subject is used to pass in Content-Type: multipart
571 * MIME header; in that case we do not have to do the
572 * plaintext content type even if the commit message has
573 * non 7-bit ASCII character. Otherwise, check if we need
574 * to say this is not a 7-bit ASCII.
576 if (fmt
== CMIT_FMT_EMAIL
&& !after_subject
) {
579 for (in_body
= i
= 0; (ch
= msg
[i
]) && i
< len
; i
++) {
581 /* author could be non 7-bit ASCII but
582 * the log may so; skip over the
586 i
+ 1 < len
&& msg
[i
+1] == '\n')
589 else if (ch
& 0x80) {
597 const char *line
= msg
;
598 int linelen
= get_one_line(msg
, len
);
604 * We want some slop for indentation and a possible
605 * final "...". Thus the "+ 20".
607 if (offset
+ linelen
+ 20 > space
) {
608 memcpy(buf
+ offset
, " ...\n", 8);
618 if ((fmt
!= CMIT_FMT_ONELINE
) && !subject
)
619 buf
[offset
++] = '\n';
622 if (fmt
== CMIT_FMT_RAW
) {
623 memcpy(buf
+ offset
, line
, linelen
);
627 if (!memcmp(line
, "parent ", 7)) {
629 die("bad parent line in commit");
633 if (!parents_shown
) {
634 offset
+= add_merge_info(fmt
, buf
+ offset
,
640 * MEDIUM == DEFAULT shows only author with dates.
641 * FULL shows both authors but not dates.
642 * FULLER shows both authors and dates.
644 if (!memcmp(line
, "author ", 7))
645 offset
+= add_user_info("Author", fmt
,
648 if (!memcmp(line
, "committer ", 10) &&
649 (fmt
== CMIT_FMT_FULL
|| fmt
== CMIT_FMT_FULLER
))
650 offset
+= add_user_info("Commit", fmt
,
656 if (is_empty_line(line
, &linelen
)) {
661 if (fmt
== CMIT_FMT_SHORT
)
668 int slen
= strlen(subject
);
669 memcpy(buf
+ offset
, subject
, slen
);
671 offset
+= add_rfc2047(buf
+ offset
, line
, linelen
);
674 memset(buf
+ offset
, ' ', indent
);
675 memcpy(buf
+ offset
+ indent
, line
, linelen
);
676 offset
+= linelen
+ indent
;
678 buf
[offset
++] = '\n';
679 if (fmt
== CMIT_FMT_ONELINE
)
681 if (subject
&& plain_non_ascii
) {
682 static const char header
[] =
683 "Content-Type: text/plain; charset=UTF-8\n"
684 "Content-Transfer-Encoding: 8bit\n";
685 memcpy(buf
+ offset
, header
, sizeof(header
)-1);
686 offset
+= sizeof(header
)-1;
689 int slen
= strlen(after_subject
);
690 if (slen
> space
- offset
- 1)
691 slen
= space
- offset
- 1;
692 memcpy(buf
+ offset
, after_subject
, slen
);
694 after_subject
= NULL
;
698 while (offset
&& isspace(buf
[offset
-1]))
700 /* Make sure there is an EOLN for the non-oneline case */
701 if (fmt
!= CMIT_FMT_ONELINE
)
702 buf
[offset
++] = '\n';
707 struct commit
*pop_commit(struct commit_list
**stack
)
709 struct commit_list
*top
= *stack
;
710 struct commit
*item
= top
? top
->item
: NULL
;
719 int count_parents(struct commit
* commit
)
722 struct commit_list
* parents
= commit
->parents
;
723 for (count
=0;parents
; parents
=parents
->next
,count
++)
728 void topo_sort_default_setter(struct commit
*c
, void *data
)
733 void *topo_sort_default_getter(struct commit
*c
)
739 * Performs an in-place topological sort on the list supplied.
741 void sort_in_topological_order(struct commit_list
** list
, int lifo
)
743 sort_in_topological_order_fn(list
, lifo
, topo_sort_default_setter
,
744 topo_sort_default_getter
);
747 void sort_in_topological_order_fn(struct commit_list
** list
, int lifo
,
748 topo_sort_set_fn_t setter
,
749 topo_sort_get_fn_t getter
)
751 struct commit_list
* next
= *list
;
752 struct commit_list
* work
= NULL
, **insert
;
753 struct commit_list
** pptr
= list
;
754 struct sort_node
* nodes
;
755 struct sort_node
* next_nodes
;
758 /* determine the size of the list */
766 /* allocate an array to help sort the list */
767 nodes
= xcalloc(count
, sizeof(*nodes
));
768 /* link the list to the array */
772 next_nodes
->list_item
= next
;
773 setter(next
->item
, next_nodes
);
777 /* update the indegree */
780 struct commit_list
* parents
= next
->item
->parents
;
782 struct commit
* parent
=parents
->item
;
783 struct sort_node
* pn
= (struct sort_node
*) getter(parent
);
787 parents
=parents
->next
;
794 * tips are nodes not reachable from any other node in the list
796 * the tips serve as a starting set for the work queue.
801 struct sort_node
* node
= (struct sort_node
*) getter(next
->item
);
803 if (node
->indegree
== 0) {
804 insert
= &commit_list_insert(next
->item
, insert
)->next
;
809 /* process the list in topological order */
813 struct commit
* work_item
= pop_commit(&work
);
814 struct sort_node
* work_node
= (struct sort_node
*) getter(work_item
);
815 struct commit_list
* parents
= work_item
->parents
;
818 struct commit
* parent
=parents
->item
;
819 struct sort_node
* pn
= (struct sort_node
*) getter(parent
);
823 * parents are only enqueued for emission
824 * when all their children have been emitted thereby
825 * guaranteeing topological order.
830 insert_by_date(parent
, &work
);
832 commit_list_insert(parent
, &work
);
835 parents
=parents
->next
;
838 * work_item is a commit all of whose children
839 * have already been emitted. we can emit it now.
841 *pptr
= work_node
->list_item
;
842 pptr
= &(*pptr
)->next
;
844 setter(work_item
, NULL
);
849 /* merge-rebase stuff */
851 /* bits #0..7 in revision.h */
852 #define PARENT1 (1u<< 8)
853 #define PARENT2 (1u<< 9)
854 #define STALE (1u<<10)
856 static struct commit
*interesting(struct commit_list
*list
)
859 struct commit
*commit
= list
->item
;
861 if (commit
->object
.flags
& STALE
)
869 * A pathological example of how this thing works.
871 * Suppose we had this commit graph, where chronologically
872 * the timestamp on the commit are A <= B <= C <= D <= E <= F
873 * and we are trying to figure out the merge base for E and F
884 * First we push E and F to list to be processed. E gets bit 1
885 * and F gets bit 2. The list becomes:
887 * list=F(2) E(1), result=empty
889 * Then we pop F, the newest commit, from the list. Its flag is 2.
890 * We scan its parents, mark them reachable from the side that F is
891 * reachable from, and push them to the list:
893 * list=E(1) D(2) A(2), result=empty
895 * Next pop E and do the same.
897 * list=D(2) B(1) A(2), result=empty
899 * Next pop D and do the same.
901 * list=C(2) B(1) A(2), result=empty
903 * Next pop C and do the same.
905 * list=B(1) A(2), result=empty
907 * Now it is B's turn. We mark its parent, C, reachable from B's side,
908 * and push it to the list:
910 * list=C(3) A(2), result=empty
912 * Now pop C and notice it has flags==3. It is placed on the result list,
913 * and the list now contains:
915 * list=A(2), result=C(3)
917 * We pop A and do the same.
919 * list=B(3), result=C(3)
921 * Next, we pop B and something very interesting happens. It has flags==3
922 * so it is also placed on the result list, and its parents are marked
923 * stale, retroactively, and placed back on the list:
925 * list=C(7), result=C(7) B(3)
927 * Now, list does not have any interesting commit. So we find the newest
928 * commit from the result list that is not marked stale. Which is
932 * Another pathological example how this thing used to fail to mark an
933 * ancestor of a merge base as STALE before we introduced the
934 * postprocessing phase (mark_reachable_commits).
950 * list A B C D E F G H
951 * G1 H2 - - - - - - 1 2
952 * H2 E1 B1 - 1 - - 1 - 1 2
953 * F2 E1 B1 A2 2 1 - - 1 2 1 2
954 * E3 B1 A2 2 1 - - 3 2 1 2
955 * B1 A2 2 1 - - 3 2 1 2
956 * C1 A2 2 1 1 - 3 2 1 2
957 * D1 A2 2 1 1 1 3 2 1 2
962 * At this point, unfortunately, everybody in the list is
963 * stale, so we fail to complete the following two
964 * steps to fully marking stale commits.
969 * and we ended up showing E as an interesting merge base.
970 * The postprocessing phase re-injects C and continues traversal
971 * to contaminate D and E.
974 static void mark_reachable_commits(struct commit_list
*result
,
975 struct commit_list
*list
)
977 struct commit_list
*tmp
;
980 * Postprocess to fully contaminate the well.
982 for (tmp
= result
; tmp
; tmp
= tmp
->next
) {
983 struct commit
*c
= tmp
->item
;
984 /* Reinject stale ones to list,
985 * so we can scan their parents.
987 if (c
->object
.flags
& STALE
)
988 commit_list_insert(c
, &list
);
991 struct commit
*c
= list
->item
;
992 struct commit_list
*parents
;
998 /* Anything taken out of the list is stale, so
999 * mark all its parents stale. We do not
1000 * parse new ones (we already parsed all the relevant
1003 parents
= c
->parents
;
1005 struct commit
*p
= parents
->item
;
1006 parents
= parents
->next
;
1007 if (!(p
->object
.flags
& STALE
)) {
1008 p
->object
.flags
|= STALE
;
1009 commit_list_insert(p
, &list
);
1015 struct commit_list
*get_merge_bases(struct commit
*rev1
, struct commit
*rev2
,
1018 struct commit_list
*list
= NULL
;
1019 struct commit_list
*result
= NULL
;
1020 struct commit_list
*tmp
= NULL
;
1023 return commit_list_insert(rev1
, &result
);
1028 rev1
->object
.flags
|= PARENT1
;
1029 rev2
->object
.flags
|= PARENT2
;
1030 insert_by_date(rev1
, &list
);
1031 insert_by_date(rev2
, &list
);
1033 while (interesting(list
)) {
1034 struct commit
*commit
= list
->item
;
1035 struct commit_list
*parents
;
1036 int flags
= commit
->object
.flags
1037 & (PARENT1
| PARENT2
| STALE
);
1042 if (flags
== (PARENT1
| PARENT2
)) {
1043 insert_by_date(commit
, &result
);
1045 /* Mark parents of a found merge stale */
1048 parents
= commit
->parents
;
1050 struct commit
*p
= parents
->item
;
1051 parents
= parents
->next
;
1052 if ((p
->object
.flags
& flags
) == flags
)
1055 p
->object
.flags
|= flags
;
1056 insert_by_date(p
, &list
);
1063 if (result
->next
&& list
)
1064 mark_reachable_commits(result
, list
);
1066 /* cull duplicates */
1067 for (tmp
= result
, list
= NULL
; tmp
; ) {
1068 struct commit
*commit
= tmp
->item
;
1069 struct commit_list
*next
= tmp
->next
;
1070 if (commit
->object
.flags
& STALE
) {
1078 commit
->object
.flags
|= STALE
;
1086 clear_commit_marks(rev1
, PARENT1
| PARENT2
| STALE
);
1087 clear_commit_marks(rev2
, PARENT1
| PARENT2
| STALE
);