6 #include "interpolate.h"
10 int save_commit_buffer
= 1;
15 * the number of children of the associated commit
16 * that also occur in the list being sorted.
18 unsigned int indegree
;
21 * reference to original list item that we will re-use
24 struct commit_list
* list_item
;
28 const char *commit_type
= "commit";
30 static struct cmt_fmt_map
{
35 { "raw", 1, CMIT_FMT_RAW
},
36 { "medium", 1, CMIT_FMT_MEDIUM
},
37 { "short", 1, CMIT_FMT_SHORT
},
38 { "email", 1, CMIT_FMT_EMAIL
},
39 { "full", 5, CMIT_FMT_FULL
},
40 { "fuller", 5, CMIT_FMT_FULLER
},
41 { "oneline", 1, CMIT_FMT_ONELINE
},
42 { "format:", 7, CMIT_FMT_USERFORMAT
},
45 static char *user_format
;
47 enum cmit_fmt
get_commit_format(const char *arg
)
52 return CMIT_FMT_DEFAULT
;
55 if (!prefixcmp(arg
, "format:")) {
58 user_format
= xstrdup(arg
+ 7);
59 return CMIT_FMT_USERFORMAT
;
61 for (i
= 0; i
< ARRAY_SIZE(cmt_fmts
); i
++) {
62 if (!strncmp(arg
, cmt_fmts
[i
].n
, cmt_fmts
[i
].cmp_len
) &&
63 !strncmp(arg
, cmt_fmts
[i
].n
, strlen(arg
)))
67 die("invalid --pretty format: %s", arg
);
70 static struct commit
*check_commit(struct object
*obj
,
71 const unsigned char *sha1
,
74 if (obj
->type
!= OBJ_COMMIT
) {
76 error("Object %s is a %s, not a commit",
77 sha1_to_hex(sha1
), typename(obj
->type
));
80 return (struct commit
*) obj
;
83 struct commit
*lookup_commit_reference_gently(const unsigned char *sha1
,
86 struct object
*obj
= deref_tag(parse_object(sha1
), NULL
, 0);
90 return check_commit(obj
, sha1
, quiet
);
93 struct commit
*lookup_commit_reference(const unsigned char *sha1
)
95 return lookup_commit_reference_gently(sha1
, 0);
98 struct commit
*lookup_commit(const unsigned char *sha1
)
100 struct object
*obj
= lookup_object(sha1
);
102 return create_object(sha1
, OBJ_COMMIT
, alloc_commit_node());
104 obj
->type
= OBJ_COMMIT
;
105 return check_commit(obj
, sha1
, 0);
108 static unsigned long parse_commit_date(const char *buf
)
112 if (memcmp(buf
, "author", 6))
114 while (*buf
++ != '\n')
116 if (memcmp(buf
, "committer", 9))
118 while (*buf
++ != '>')
120 date
= strtoul(buf
, NULL
, 10);
121 if (date
== ULONG_MAX
)
126 static struct commit_graft
**commit_graft
;
127 static int commit_graft_alloc
, commit_graft_nr
;
129 static int commit_graft_pos(const unsigned char *sha1
)
133 hi
= commit_graft_nr
;
135 int mi
= (lo
+ hi
) / 2;
136 struct commit_graft
*graft
= commit_graft
[mi
];
137 int cmp
= hashcmp(sha1
, graft
->sha1
);
148 int register_commit_graft(struct commit_graft
*graft
, int ignore_dups
)
150 int pos
= commit_graft_pos(graft
->sha1
);
156 free(commit_graft
[pos
]);
157 commit_graft
[pos
] = graft
;
162 if (commit_graft_alloc
<= ++commit_graft_nr
) {
163 commit_graft_alloc
= alloc_nr(commit_graft_alloc
);
164 commit_graft
= xrealloc(commit_graft
,
165 sizeof(*commit_graft
) *
168 if (pos
< commit_graft_nr
)
169 memmove(commit_graft
+ pos
+ 1,
171 (commit_graft_nr
- pos
- 1) *
172 sizeof(*commit_graft
));
173 commit_graft
[pos
] = graft
;
177 struct commit_graft
*read_graft_line(char *buf
, int len
)
179 /* The format is just "Commit Parent1 Parent2 ...\n" */
181 struct commit_graft
*graft
= NULL
;
183 if (buf
[len
-1] == '\n')
185 if (buf
[0] == '#' || buf
[0] == '\0')
187 if ((len
+ 1) % 41) {
189 error("bad graft data: %s", buf
);
193 i
= (len
+ 1) / 41 - 1;
194 graft
= xmalloc(sizeof(*graft
) + 20 * i
);
195 graft
->nr_parent
= i
;
196 if (get_sha1_hex(buf
, graft
->sha1
))
198 for (i
= 40; i
< len
; i
+= 41) {
201 if (get_sha1_hex(buf
+ i
+ 1, graft
->parent
[i
/41]))
207 int read_graft_file(const char *graft_file
)
209 FILE *fp
= fopen(graft_file
, "r");
213 while (fgets(buf
, sizeof(buf
), fp
)) {
214 /* The format is just "Commit Parent1 Parent2 ...\n" */
215 int len
= strlen(buf
);
216 struct commit_graft
*graft
= read_graft_line(buf
, len
);
219 if (register_commit_graft(graft
, 1))
220 error("duplicate graft data: %s", buf
);
226 static void prepare_commit_graft(void)
228 static int commit_graft_prepared
;
231 if (commit_graft_prepared
)
233 graft_file
= get_graft_file();
234 read_graft_file(graft_file
);
235 /* make sure shallows are read */
236 is_repository_shallow();
237 commit_graft_prepared
= 1;
240 static struct commit_graft
*lookup_commit_graft(const unsigned char *sha1
)
243 prepare_commit_graft();
244 pos
= commit_graft_pos(sha1
);
247 return commit_graft
[pos
];
250 int write_shallow_commits(int fd
, int use_pack_protocol
)
253 for (i
= 0; i
< commit_graft_nr
; i
++)
254 if (commit_graft
[i
]->nr_parent
< 0) {
256 sha1_to_hex(commit_graft
[i
]->sha1
);
258 if (use_pack_protocol
)
259 packet_write(fd
, "shallow %s", hex
);
261 if (write_in_full(fd
, hex
, 40) != 40)
263 if (write_in_full(fd
, "\n", 1) != 1)
270 int unregister_shallow(const unsigned char *sha1
)
272 int pos
= commit_graft_pos(sha1
);
275 if (pos
+ 1 < commit_graft_nr
)
276 memcpy(commit_graft
+ pos
, commit_graft
+ pos
+ 1,
277 sizeof(struct commit_graft
*)
278 * (commit_graft_nr
- pos
- 1));
283 int parse_commit_buffer(struct commit
*item
, void *buffer
, unsigned long size
)
286 char *bufptr
= buffer
;
287 unsigned char parent
[20];
288 struct commit_list
**pptr
;
289 struct commit_graft
*graft
;
292 if (item
->object
.parsed
)
294 item
->object
.parsed
= 1;
296 if (tail
<= bufptr
+ 5 || memcmp(bufptr
, "tree ", 5))
297 return error("bogus commit object %s", sha1_to_hex(item
->object
.sha1
));
298 if (tail
<= bufptr
+ 45 || get_sha1_hex(bufptr
+ 5, parent
) < 0)
299 return error("bad tree pointer in commit %s",
300 sha1_to_hex(item
->object
.sha1
));
301 item
->tree
= lookup_tree(parent
);
304 bufptr
+= 46; /* "tree " + "hex sha1" + "\n" */
305 pptr
= &item
->parents
;
307 graft
= lookup_commit_graft(item
->object
.sha1
);
308 while (bufptr
+ 48 < tail
&& !memcmp(bufptr
, "parent ", 7)) {
309 struct commit
*new_parent
;
311 if (tail
<= bufptr
+ 48 ||
312 get_sha1_hex(bufptr
+ 7, parent
) ||
314 return error("bad parents in commit %s", sha1_to_hex(item
->object
.sha1
));
318 new_parent
= lookup_commit(parent
);
320 pptr
= &commit_list_insert(new_parent
, pptr
)->next
;
326 struct commit
*new_parent
;
327 for (i
= 0; i
< graft
->nr_parent
; i
++) {
328 new_parent
= lookup_commit(graft
->parent
[i
]);
331 pptr
= &commit_list_insert(new_parent
, pptr
)->next
;
335 item
->date
= parse_commit_date(bufptr
);
337 if (track_object_refs
) {
339 struct commit_list
*p
;
340 struct object_refs
*refs
= alloc_object_refs(n_refs
);
342 refs
->ref
[i
++] = &item
->tree
->object
;
343 for (p
= item
->parents
; p
; p
= p
->next
)
344 refs
->ref
[i
++] = &p
->item
->object
;
345 set_object_refs(&item
->object
, refs
);
351 int parse_commit(struct commit
*item
)
353 enum object_type type
;
358 if (item
->object
.parsed
)
360 buffer
= read_sha1_file(item
->object
.sha1
, &type
, &size
);
362 return error("Could not read %s",
363 sha1_to_hex(item
->object
.sha1
));
364 if (type
!= OBJ_COMMIT
) {
366 return error("Object %s not a commit",
367 sha1_to_hex(item
->object
.sha1
));
369 ret
= parse_commit_buffer(item
, buffer
, size
);
370 if (save_commit_buffer
&& !ret
) {
371 item
->buffer
= buffer
;
378 struct commit_list
*commit_list_insert(struct commit
*item
, struct commit_list
**list_p
)
380 struct commit_list
*new_list
= xmalloc(sizeof(struct commit_list
));
381 new_list
->item
= item
;
382 new_list
->next
= *list_p
;
387 void free_commit_list(struct commit_list
*list
)
390 struct commit_list
*temp
= list
;
396 struct commit_list
* insert_by_date(struct commit
*item
, struct commit_list
**list
)
398 struct commit_list
**pp
= list
;
399 struct commit_list
*p
;
400 while ((p
= *pp
) != NULL
) {
401 if (p
->item
->date
< item
->date
) {
406 return commit_list_insert(item
, pp
);
410 void sort_by_date(struct commit_list
**list
)
412 struct commit_list
*ret
= NULL
;
414 insert_by_date((*list
)->item
, &ret
);
415 *list
= (*list
)->next
;
420 struct commit
*pop_most_recent_commit(struct commit_list
**list
,
423 struct commit
*ret
= (*list
)->item
;
424 struct commit_list
*parents
= ret
->parents
;
425 struct commit_list
*old
= *list
;
427 *list
= (*list
)->next
;
431 struct commit
*commit
= parents
->item
;
432 parse_commit(commit
);
433 if (!(commit
->object
.flags
& mark
)) {
434 commit
->object
.flags
|= mark
;
435 insert_by_date(commit
, list
);
437 parents
= parents
->next
;
442 void clear_commit_marks(struct commit
*commit
, unsigned int mark
)
444 struct commit_list
*parents
;
446 commit
->object
.flags
&= ~mark
;
447 parents
= commit
->parents
;
449 struct commit
*parent
= parents
->item
;
451 /* Have we already cleared this? */
452 if (mark
& parent
->object
.flags
)
453 clear_commit_marks(parent
, mark
);
454 parents
= parents
->next
;
459 * Generic support for pretty-printing the header
461 static int get_one_line(const char *msg
)
476 /* High bit set, or ISO-2022-INT */
477 static int non_ascii(int ch
)
480 return ((ch
& 0x80) || (ch
== 0x1b));
483 static int is_rfc2047_special(char ch
)
485 return (non_ascii(ch
) || (ch
== '=') || (ch
== '?') || (ch
== '_'));
488 static void add_rfc2047(struct strbuf
*sb
, const char *line
, int len
,
489 const char *encoding
)
493 for (i
= 0; i
< len
; i
++) {
497 if ((i
+ 1 < len
) && (ch
== '=' && line
[i
+1] == '?'))
500 strbuf_add(sb
, line
, len
);
504 strbuf_addf(sb
, "=?%s?q?", encoding
);
505 for (i
= last
= 0; i
< len
; i
++) {
506 unsigned ch
= line
[i
] & 0xFF;
508 * We encode ' ' using '=20' even though rfc2047
509 * allows using '_' for readability. Unfortunately,
510 * many programs do not understand this and just
511 * leave the underscore in place.
513 if (is_rfc2047_special(ch
) || ch
== ' ') {
514 strbuf_add(sb
, line
+ last
, i
- last
);
515 strbuf_addf(sb
, "=%02X", ch
);
519 strbuf_add(sb
, line
+ last
, len
- last
);
520 strbuf_addstr(sb
, "?=");
523 static unsigned long bound_rfc2047(unsigned long len
, const char *encoding
)
525 /* upper bound of q encoded string of length 'len' */
526 unsigned long elen
= strlen(encoding
);
528 return len
* 3 + elen
+ 100;
531 static void add_user_info(const char *what
, enum cmit_fmt fmt
, struct strbuf
*sb
,
532 const char *line
, enum date_mode dmode
,
533 const char *encoding
)
539 const char *filler
= " ";
541 if (fmt
== CMIT_FMT_ONELINE
)
543 date
= strchr(line
, '>');
546 namelen
= ++date
- line
;
547 time
= strtoul(date
, &date
, 10);
548 tz
= strtol(date
, NULL
, 10);
550 if (fmt
== CMIT_FMT_EMAIL
) {
551 char *name_tail
= strchr(line
, '<');
552 int display_name_length
;
555 while (line
< name_tail
&& isspace(name_tail
[-1]))
557 display_name_length
= name_tail
- line
;
559 strbuf_addstr(sb
, "From: ");
560 add_rfc2047(sb
, line
, display_name_length
, encoding
);
561 strbuf_add(sb
, name_tail
, namelen
- display_name_length
);
562 strbuf_addch(sb
, '\n');
565 strbuf_addf(sb
, "%s: %.*s%.*s\n", what
,
566 (fmt
== CMIT_FMT_FULLER
) ? 4 : 0,
567 filler
, namelen
, line
);
570 case CMIT_FMT_MEDIUM
:
571 strbuf_addf(sb
, "Date: %s\n", show_date(time
, tz
, dmode
));
574 strbuf_addf(sb
, "Date: %s\n", show_date(time
, tz
, DATE_RFC2822
));
576 case CMIT_FMT_FULLER
:
577 strbuf_addf(sb
, "%sDate: %s\n", what
, show_date(time
, tz
, dmode
));
585 static int is_empty_line(const char *line
, int *len_p
)
588 while (len
&& isspace(line
[len
-1]))
594 static void add_merge_info(enum cmit_fmt fmt
, struct strbuf
*sb
,
595 const struct commit
*commit
, int abbrev
)
597 struct commit_list
*parent
= commit
->parents
;
599 if ((fmt
== CMIT_FMT_ONELINE
) || (fmt
== CMIT_FMT_EMAIL
) ||
600 !parent
|| !parent
->next
)
603 strbuf_addstr(sb
, "Merge:");
606 struct commit
*p
= parent
->item
;
607 const char *hex
= NULL
;
610 hex
= find_unique_abbrev(p
->object
.sha1
, abbrev
);
612 hex
= sha1_to_hex(p
->object
.sha1
);
613 dots
= (abbrev
&& strlen(hex
) != 40) ? "..." : "";
614 parent
= parent
->next
;
616 strbuf_addf(sb
, " %s%s", hex
, dots
);
618 strbuf_addch(sb
, '\n');
621 static char *get_header(const struct commit
*commit
, const char *key
)
623 int key_len
= strlen(key
);
624 const char *line
= commit
->buffer
;
627 const char *eol
= strchr(line
, '\n'), *next
;
632 eol
= line
+ strlen(line
);
636 if (eol
- line
> key_len
&&
637 !strncmp(line
, key
, key_len
) &&
638 line
[key_len
] == ' ') {
639 int len
= eol
- line
- key_len
;
640 char *ret
= xmalloc(len
);
641 memcpy(ret
, line
+ key_len
+ 1, len
- 1);
649 static char *replace_encoding_header(char *buf
, const char *encoding
)
655 /* guess if there is an encoding header before a \n\n */
656 while (strncmp(cp
, "encoding ", strlen("encoding "))) {
657 cp
= strchr(cp
, '\n');
658 if (!cp
|| *++cp
== '\n')
662 cp
= strchr(cp
, '\n');
664 return buf
; /* should not happen but be defensive */
665 len
= cp
+ 1 - (buf
+ start
);
667 strbuf_init(&tmp
, 0);
668 strbuf_attach(&tmp
, buf
, strlen(buf
), strlen(buf
) + 1);
669 if (is_encoding_utf8(encoding
)) {
670 /* we have re-coded to UTF-8; drop the header */
671 strbuf_splice(&tmp
, start
, len
, NULL
, 0);
673 /* just replaces XXXX in 'encoding XXXX\n' */
674 strbuf_splice(&tmp
, start
+ strlen("encoding "),
675 len
- strlen("encoding \n"),
676 encoding
, strlen(encoding
));
681 static char *logmsg_reencode(const struct commit
*commit
,
682 const char *output_encoding
)
684 static const char *utf8
= "utf-8";
685 const char *use_encoding
;
689 if (!*output_encoding
)
691 encoding
= get_header(commit
, "encoding");
692 use_encoding
= encoding
? encoding
: utf8
;
693 if (!strcmp(use_encoding
, output_encoding
))
694 if (encoding
) /* we'll strip encoding header later */
695 out
= xstrdup(commit
->buffer
);
697 return NULL
; /* nothing to do */
699 out
= reencode_string(commit
->buffer
,
700 output_encoding
, use_encoding
);
702 out
= replace_encoding_header(out
, output_encoding
);
708 static void fill_person(struct interp
*table
, const char *msg
, int len
)
710 int start
, end
, tz
= 0;
715 for (end
= 0; end
< len
&& msg
[end
] != '<'; end
++)
718 while (end
> 0 && isspace(msg
[end
- 1]))
720 table
[0].value
= xstrndup(msg
, end
);
726 for (end
= start
+ 1; end
< len
&& msg
[end
] != '>'; end
++)
732 table
[1].value
= xstrndup(msg
+ start
, end
- start
);
735 for (start
= end
+ 1; start
< len
&& isspace(msg
[start
]); start
++)
739 date
= strtoul(msg
+ start
, &ep
, 10);
740 if (msg
+ start
== ep
)
743 table
[5].value
= xstrndup(msg
+ start
, ep
- (msg
+ start
));
746 for (start
= ep
- msg
+ 1; start
< len
&& isspace(msg
[start
]); start
++)
748 if (start
+ 1 < len
) {
749 tz
= strtoul(msg
+ start
+ 1, NULL
, 10);
750 if (msg
[start
] == '-')
754 interp_set_entry(table
, 2, show_date(date
, tz
, DATE_NORMAL
));
755 interp_set_entry(table
, 3, show_date(date
, tz
, DATE_RFC2822
));
756 interp_set_entry(table
, 4, show_date(date
, tz
, DATE_RELATIVE
));
757 interp_set_entry(table
, 6, show_date(date
, tz
, DATE_ISO8601
));
760 void format_commit_message(const struct commit
*commit
,
761 const void *format
, struct strbuf
*sb
)
763 struct interp table
[] = {
764 { "%H" }, /* commit hash */
765 { "%h" }, /* abbreviated commit hash */
766 { "%T" }, /* tree hash */
767 { "%t" }, /* abbreviated tree hash */
768 { "%P" }, /* parent hashes */
769 { "%p" }, /* abbreviated parent hashes */
770 { "%an" }, /* author name */
771 { "%ae" }, /* author email */
772 { "%ad" }, /* author date */
773 { "%aD" }, /* author date, RFC2822 style */
774 { "%ar" }, /* author date, relative */
775 { "%at" }, /* author date, UNIX timestamp */
776 { "%ai" }, /* author date, ISO 8601 */
777 { "%cn" }, /* committer name */
778 { "%ce" }, /* committer email */
779 { "%cd" }, /* committer date */
780 { "%cD" }, /* committer date, RFC2822 style */
781 { "%cr" }, /* committer date, relative */
782 { "%ct" }, /* committer date, UNIX timestamp */
783 { "%ci" }, /* committer date, ISO 8601 */
784 { "%e" }, /* encoding */
785 { "%s" }, /* subject */
787 { "%Cred" }, /* red */
788 { "%Cgreen" }, /* green */
789 { "%Cblue" }, /* blue */
790 { "%Creset" }, /* reset color */
791 { "%n" }, /* newline */
792 { "%m" }, /* left/right/bottom */
795 IHASH
= 0, IHASH_ABBREV
,
797 IPARENTS
, IPARENTS_ABBREV
,
798 IAUTHOR_NAME
, IAUTHOR_EMAIL
,
799 IAUTHOR_DATE
, IAUTHOR_DATE_RFC2822
, IAUTHOR_DATE_RELATIVE
,
800 IAUTHOR_TIMESTAMP
, IAUTHOR_ISO8601
,
801 ICOMMITTER_NAME
, ICOMMITTER_EMAIL
,
802 ICOMMITTER_DATE
, ICOMMITTER_DATE_RFC2822
,
803 ICOMMITTER_DATE_RELATIVE
, ICOMMITTER_TIMESTAMP
,
808 IRED
, IGREEN
, IBLUE
, IRESET_COLOR
,
812 struct commit_list
*p
;
816 enum { HEADER
, SUBJECT
, BODY
} state
;
817 const char *msg
= commit
->buffer
;
819 if (ILEFT_RIGHT
+ 1 != ARRAY_SIZE(table
))
820 die("invalid interp table!");
822 /* these are independent of the commit */
823 interp_set_entry(table
, IRED
, "\033[31m");
824 interp_set_entry(table
, IGREEN
, "\033[32m");
825 interp_set_entry(table
, IBLUE
, "\033[34m");
826 interp_set_entry(table
, IRESET_COLOR
, "\033[m");
827 interp_set_entry(table
, INEWLINE
, "\n");
829 /* these depend on the commit */
830 if (!commit
->object
.parsed
)
831 parse_object(commit
->object
.sha1
);
832 interp_set_entry(table
, IHASH
, sha1_to_hex(commit
->object
.sha1
));
833 interp_set_entry(table
, IHASH_ABBREV
,
834 find_unique_abbrev(commit
->object
.sha1
,
836 interp_set_entry(table
, ITREE
, sha1_to_hex(commit
->tree
->object
.sha1
));
837 interp_set_entry(table
, ITREE_ABBREV
,
838 find_unique_abbrev(commit
->tree
->object
.sha1
,
840 interp_set_entry(table
, ILEFT_RIGHT
,
841 (commit
->object
.flags
& BOUNDARY
)
843 : (commit
->object
.flags
& SYMMETRIC_LEFT
)
848 for (i
= 0, p
= commit
->parents
;
849 p
&& i
< sizeof(parents
) - 1;
851 i
+= snprintf(parents
+ i
, sizeof(parents
) - i
- 1, " %s",
852 sha1_to_hex(p
->item
->object
.sha1
));
853 interp_set_entry(table
, IPARENTS
, parents
+ 1);
856 for (i
= 0, p
= commit
->parents
;
857 p
&& i
< sizeof(parents
) - 1;
859 i
+= snprintf(parents
+ i
, sizeof(parents
) - i
- 1, " %s",
860 find_unique_abbrev(p
->item
->object
.sha1
,
862 interp_set_entry(table
, IPARENTS_ABBREV
, parents
+ 1);
864 for (i
= 0, state
= HEADER
; msg
[i
] && state
< BODY
; i
++) {
866 for (eol
= i
; msg
[eol
] && msg
[eol
] != '\n'; eol
++)
869 if (state
== SUBJECT
) {
870 table
[ISUBJECT
].value
= xstrndup(msg
+ i
, eol
- i
);
875 /* strip empty lines */
876 while (msg
[eol
+ 1] == '\n')
878 } else if (!prefixcmp(msg
+ i
, "author "))
879 fill_person(table
+ IAUTHOR_NAME
,
880 msg
+ i
+ 7, eol
- i
- 7);
881 else if (!prefixcmp(msg
+ i
, "committer "))
882 fill_person(table
+ ICOMMITTER_NAME
,
883 msg
+ i
+ 10, eol
- i
- 10);
884 else if (!prefixcmp(msg
+ i
, "encoding "))
885 table
[IENCODING
].value
=
886 xstrndup(msg
+ i
+ 9, eol
- i
- 9);
890 table
[IBODY
].value
= xstrdup(msg
+ i
);
891 for (i
= 0; i
< ARRAY_SIZE(table
); i
++)
893 interp_set_entry(table
, i
, "<unknown>");
895 len
= interpolate(sb
->buf
+ sb
->len
, strbuf_avail(sb
),
896 format
, table
, ARRAY_SIZE(table
));
897 if (len
> strbuf_avail(sb
)) {
898 strbuf_grow(sb
, len
);
899 interpolate(sb
->buf
+ sb
->len
, strbuf_avail(sb
) + 1,
900 format
, table
, ARRAY_SIZE(table
));
902 strbuf_setlen(sb
, sb
->len
+ len
);
903 interp_clear_table(table
, ARRAY_SIZE(table
));
906 static void pp_header(enum cmit_fmt fmt
,
908 enum date_mode dmode
,
909 const char *encoding
,
910 const struct commit
*commit
,
914 int parents_shown
= 0;
917 const char *line
= *msg_p
;
918 int linelen
= get_one_line(*msg_p
);
928 if (fmt
== CMIT_FMT_RAW
) {
929 strbuf_add(sb
, line
, linelen
);
933 if (!memcmp(line
, "parent ", 7)) {
935 die("bad parent line in commit");
939 if (!parents_shown
) {
940 struct commit_list
*parent
;
942 for (parent
= commit
->parents
, num
= 0;
944 parent
= parent
->next
, num
++)
946 /* with enough slop */
947 strbuf_grow(sb
, num
* 50 + 20);
948 add_merge_info(fmt
, sb
, commit
, abbrev
);
953 * MEDIUM == DEFAULT shows only author with dates.
954 * FULL shows both authors but not dates.
955 * FULLER shows both authors and dates.
957 if (!memcmp(line
, "author ", 7)) {
958 unsigned long len
= linelen
;
959 if (fmt
== CMIT_FMT_EMAIL
)
960 len
= bound_rfc2047(linelen
, encoding
);
961 strbuf_grow(sb
, len
+ 80);
962 add_user_info("Author", fmt
, sb
, line
+ 7, dmode
, encoding
);
965 if (!memcmp(line
, "committer ", 10) &&
966 (fmt
== CMIT_FMT_FULL
|| fmt
== CMIT_FMT_FULLER
)) {
967 unsigned long len
= linelen
;
968 if (fmt
== CMIT_FMT_EMAIL
)
969 len
= bound_rfc2047(linelen
, encoding
);
970 strbuf_grow(sb
, len
+ 80);
971 add_user_info("Commit", fmt
, sb
, line
+ 10, dmode
, encoding
);
976 static void pp_title_line(enum cmit_fmt fmt
,
980 const char *after_subject
,
981 const char *encoding
,
987 strbuf_init(&title
, 80);
990 const char *line
= *msg_p
;
991 int linelen
= get_one_line(line
);
994 if (!linelen
|| is_empty_line(line
, &linelen
))
997 strbuf_grow(&title
, linelen
+ 2);
999 if (fmt
== CMIT_FMT_EMAIL
) {
1000 strbuf_addch(&title
, '\n');
1002 strbuf_addch(&title
, ' ');
1004 strbuf_add(&title
, line
, linelen
);
1007 /* Enough slop for the MIME header and rfc2047 */
1008 len
= bound_rfc2047(title
.len
, encoding
) + 1000;
1010 len
+= strlen(subject
);
1012 len
+= strlen(after_subject
);
1014 len
+= strlen(encoding
);
1016 strbuf_grow(sb
, title
.len
+ len
);
1018 strbuf_addstr(sb
, subject
);
1019 add_rfc2047(sb
, title
.buf
, title
.len
, encoding
);
1021 strbuf_addbuf(sb
, &title
);
1023 strbuf_addch(sb
, '\n');
1025 if (plain_non_ascii
) {
1026 const char *header_fmt
=
1027 "MIME-Version: 1.0\n"
1028 "Content-Type: text/plain; charset=%s\n"
1029 "Content-Transfer-Encoding: 8bit\n";
1030 strbuf_addf(sb
, header_fmt
, encoding
);
1032 if (after_subject
) {
1033 strbuf_addstr(sb
, after_subject
);
1035 if (fmt
== CMIT_FMT_EMAIL
) {
1036 strbuf_addch(sb
, '\n');
1038 strbuf_release(&title
);
1041 static void pp_remainder(enum cmit_fmt fmt
,
1048 const char *line
= *msg_p
;
1049 int linelen
= get_one_line(line
);
1055 if (is_empty_line(line
, &linelen
)) {
1058 if (fmt
== CMIT_FMT_SHORT
)
1063 strbuf_grow(sb
, linelen
+ indent
+ 20);
1065 memset(sb
->buf
+ sb
->len
, ' ', indent
);
1066 strbuf_setlen(sb
, sb
->len
+ indent
);
1068 strbuf_add(sb
, line
, linelen
);
1069 strbuf_addch(sb
, '\n');
1073 void pretty_print_commit(enum cmit_fmt fmt
, const struct commit
*commit
,
1074 struct strbuf
*sb
, int abbrev
,
1075 const char *subject
, const char *after_subject
,
1076 enum date_mode dmode
)
1078 unsigned long beginning_of_body
;
1080 const char *msg
= commit
->buffer
;
1081 int plain_non_ascii
= 0;
1083 const char *encoding
;
1085 if (fmt
== CMIT_FMT_USERFORMAT
) {
1086 format_commit_message(commit
, user_format
, sb
);
1090 encoding
= (git_log_output_encoding
1091 ? git_log_output_encoding
1092 : git_commit_encoding
);
1095 reencoded
= logmsg_reencode(commit
, encoding
);
1100 if (fmt
== CMIT_FMT_ONELINE
|| fmt
== CMIT_FMT_EMAIL
)
1103 /* After-subject is used to pass in Content-Type: multipart
1104 * MIME header; in that case we do not have to do the
1105 * plaintext content type even if the commit message has
1106 * non 7-bit ASCII character. Otherwise, check if we need
1107 * to say this is not a 7-bit ASCII.
1109 if (fmt
== CMIT_FMT_EMAIL
&& !after_subject
) {
1112 for (in_body
= i
= 0; (ch
= msg
[i
]); i
++) {
1114 /* author could be non 7-bit ASCII but
1115 * the log may be so; skip over the
1116 * header part first.
1118 if (ch
== '\n' && msg
[i
+1] == '\n')
1121 else if (non_ascii(ch
)) {
1122 plain_non_ascii
= 1;
1128 pp_header(fmt
, abbrev
, dmode
, encoding
, commit
, &msg
, sb
);
1129 if (fmt
!= CMIT_FMT_ONELINE
&& !subject
) {
1130 strbuf_addch(sb
, '\n');
1133 /* Skip excess blank lines at the beginning of body, if any... */
1135 int linelen
= get_one_line(msg
);
1139 if (!is_empty_line(msg
, &ll
))
1144 /* These formats treat the title line specially. */
1145 if (fmt
== CMIT_FMT_ONELINE
|| fmt
== CMIT_FMT_EMAIL
)
1146 pp_title_line(fmt
, &msg
, sb
, subject
,
1147 after_subject
, encoding
, plain_non_ascii
);
1149 beginning_of_body
= sb
->len
;
1150 if (fmt
!= CMIT_FMT_ONELINE
)
1151 pp_remainder(fmt
, &msg
, sb
, indent
);
1154 /* Make sure there is an EOLN for the non-oneline case */
1155 if (fmt
!= CMIT_FMT_ONELINE
)
1156 strbuf_addch(sb
, '\n');
1159 * The caller may append additional body text in e-mail
1160 * format. Make sure we did not strip the blank line
1161 * between the header and the body.
1163 if (fmt
== CMIT_FMT_EMAIL
&& sb
->len
<= beginning_of_body
)
1164 strbuf_addch(sb
, '\n');
1168 struct commit
*pop_commit(struct commit_list
**stack
)
1170 struct commit_list
*top
= *stack
;
1171 struct commit
*item
= top
? top
->item
: NULL
;
1180 void topo_sort_default_setter(struct commit
*c
, void *data
)
1185 void *topo_sort_default_getter(struct commit
*c
)
1191 * Performs an in-place topological sort on the list supplied.
1193 void sort_in_topological_order(struct commit_list
** list
, int lifo
)
1195 sort_in_topological_order_fn(list
, lifo
, topo_sort_default_setter
,
1196 topo_sort_default_getter
);
1199 void sort_in_topological_order_fn(struct commit_list
** list
, int lifo
,
1200 topo_sort_set_fn_t setter
,
1201 topo_sort_get_fn_t getter
)
1203 struct commit_list
* next
= *list
;
1204 struct commit_list
* work
= NULL
, **insert
;
1205 struct commit_list
** pptr
= list
;
1206 struct sort_node
* nodes
;
1207 struct sort_node
* next_nodes
;
1210 /* determine the size of the list */
1218 /* allocate an array to help sort the list */
1219 nodes
= xcalloc(count
, sizeof(*nodes
));
1220 /* link the list to the array */
1224 next_nodes
->list_item
= next
;
1225 setter(next
->item
, next_nodes
);
1229 /* update the indegree */
1232 struct commit_list
* parents
= next
->item
->parents
;
1234 struct commit
* parent
=parents
->item
;
1235 struct sort_node
* pn
= (struct sort_node
*) getter(parent
);
1239 parents
=parents
->next
;
1246 * tips are nodes not reachable from any other node in the list
1248 * the tips serve as a starting set for the work queue.
1253 struct sort_node
* node
= (struct sort_node
*) getter(next
->item
);
1255 if (node
->indegree
== 0) {
1256 insert
= &commit_list_insert(next
->item
, insert
)->next
;
1261 /* process the list in topological order */
1263 sort_by_date(&work
);
1265 struct commit
* work_item
= pop_commit(&work
);
1266 struct sort_node
* work_node
= (struct sort_node
*) getter(work_item
);
1267 struct commit_list
* parents
= work_item
->parents
;
1270 struct commit
* parent
=parents
->item
;
1271 struct sort_node
* pn
= (struct sort_node
*) getter(parent
);
1275 * parents are only enqueued for emission
1276 * when all their children have been emitted thereby
1277 * guaranteeing topological order.
1280 if (!pn
->indegree
) {
1282 insert_by_date(parent
, &work
);
1284 commit_list_insert(parent
, &work
);
1287 parents
=parents
->next
;
1290 * work_item is a commit all of whose children
1291 * have already been emitted. we can emit it now.
1293 *pptr
= work_node
->list_item
;
1294 pptr
= &(*pptr
)->next
;
1296 setter(work_item
, NULL
);
1301 /* merge-base stuff */
1303 /* bits #0..15 in revision.h */
1304 #define PARENT1 (1u<<16)
1305 #define PARENT2 (1u<<17)
1306 #define STALE (1u<<18)
1307 #define RESULT (1u<<19)
1309 static const unsigned all_flags
= (PARENT1
| PARENT2
| STALE
| RESULT
);
1311 static struct commit
*interesting(struct commit_list
*list
)
1314 struct commit
*commit
= list
->item
;
1316 if (commit
->object
.flags
& STALE
)
1323 static struct commit_list
*merge_bases(struct commit
*one
, struct commit
*two
)
1325 struct commit_list
*list
= NULL
;
1326 struct commit_list
*result
= NULL
;
1329 /* We do not mark this even with RESULT so we do not
1330 * have to clean it up.
1332 return commit_list_insert(one
, &result
);
1337 one
->object
.flags
|= PARENT1
;
1338 two
->object
.flags
|= PARENT2
;
1339 insert_by_date(one
, &list
);
1340 insert_by_date(two
, &list
);
1342 while (interesting(list
)) {
1343 struct commit
*commit
;
1344 struct commit_list
*parents
;
1345 struct commit_list
*n
;
1348 commit
= list
->item
;
1353 flags
= commit
->object
.flags
& (PARENT1
| PARENT2
| STALE
);
1354 if (flags
== (PARENT1
| PARENT2
)) {
1355 if (!(commit
->object
.flags
& RESULT
)) {
1356 commit
->object
.flags
|= RESULT
;
1357 insert_by_date(commit
, &result
);
1359 /* Mark parents of a found merge stale */
1362 parents
= commit
->parents
;
1364 struct commit
*p
= parents
->item
;
1365 parents
= parents
->next
;
1366 if ((p
->object
.flags
& flags
) == flags
)
1369 p
->object
.flags
|= flags
;
1370 insert_by_date(p
, &list
);
1374 /* Clean up the result to remove stale ones */
1375 free_commit_list(list
);
1376 list
= result
; result
= NULL
;
1378 struct commit_list
*n
= list
->next
;
1379 if (!(list
->item
->object
.flags
& STALE
))
1380 insert_by_date(list
->item
, &result
);
1387 struct commit_list
*get_merge_bases(struct commit
*one
,
1388 struct commit
*two
, int cleanup
)
1390 struct commit_list
*list
;
1391 struct commit
**rslt
;
1392 struct commit_list
*result
;
1395 result
= merge_bases(one
, two
);
1398 if (!result
|| !result
->next
) {
1400 clear_commit_marks(one
, all_flags
);
1401 clear_commit_marks(two
, all_flags
);
1406 /* There are more than one */
1413 rslt
= xcalloc(cnt
, sizeof(*rslt
));
1414 for (list
= result
, i
= 0; list
; list
= list
->next
)
1415 rslt
[i
++] = list
->item
;
1416 free_commit_list(result
);
1418 clear_commit_marks(one
, all_flags
);
1419 clear_commit_marks(two
, all_flags
);
1420 for (i
= 0; i
< cnt
- 1; i
++) {
1421 for (j
= i
+1; j
< cnt
; j
++) {
1422 if (!rslt
[i
] || !rslt
[j
])
1424 result
= merge_bases(rslt
[i
], rslt
[j
]);
1425 clear_commit_marks(rslt
[i
], all_flags
);
1426 clear_commit_marks(rslt
[j
], all_flags
);
1427 for (list
= result
; list
; list
= list
->next
) {
1428 if (rslt
[i
] == list
->item
)
1430 if (rslt
[j
] == list
->item
)
1436 /* Surviving ones in rslt[] are the independent results */
1438 for (i
= 0; i
< cnt
; i
++) {
1440 insert_by_date(rslt
[i
], &result
);
1446 int in_merge_bases(struct commit
*commit
, struct commit
**reference
, int num
)
1448 struct commit_list
*bases
, *b
;
1452 bases
= get_merge_bases(commit
, *reference
, 1);
1455 for (b
= bases
; b
; b
= b
->next
) {
1456 if (!hashcmp(commit
->object
.sha1
, b
->item
->object
.sha1
)) {
1462 free_commit_list(bases
);