6 #include "interpolate.h"
8 int save_commit_buffer
= 1;
13 * the number of children of the associated commit
14 * that also occur in the list being sorted.
16 unsigned int indegree
;
19 * reference to original list item that we will re-use
22 struct commit_list
* list_item
;
26 const char *commit_type
= "commit";
33 { "raw", 1, CMIT_FMT_RAW
},
34 { "medium", 1, CMIT_FMT_MEDIUM
},
35 { "short", 1, CMIT_FMT_SHORT
},
36 { "email", 1, CMIT_FMT_EMAIL
},
37 { "full", 5, CMIT_FMT_FULL
},
38 { "fuller", 5, CMIT_FMT_FULLER
},
39 { "oneline", 1, CMIT_FMT_ONELINE
},
40 { "format:", 7, CMIT_FMT_USERFORMAT
},
43 static char *user_format
;
45 enum cmit_fmt
get_commit_format(const char *arg
)
50 return CMIT_FMT_DEFAULT
;
53 if (!prefixcmp(arg
, "format:")) {
56 user_format
= xstrdup(arg
+ 7);
57 return CMIT_FMT_USERFORMAT
;
59 for (i
= 0; i
< ARRAY_SIZE(cmt_fmts
); i
++) {
60 if (!strncmp(arg
, cmt_fmts
[i
].n
, cmt_fmts
[i
].cmp_len
) &&
61 !strncmp(arg
, cmt_fmts
[i
].n
, strlen(arg
)))
65 die("invalid --pretty format: %s", arg
);
68 static struct commit
*check_commit(struct object
*obj
,
69 const unsigned char *sha1
,
72 if (obj
->type
!= OBJ_COMMIT
) {
74 error("Object %s is a %s, not a commit",
75 sha1_to_hex(sha1
), typename(obj
->type
));
78 return (struct commit
*) obj
;
81 struct commit
*lookup_commit_reference_gently(const unsigned char *sha1
,
84 struct object
*obj
= deref_tag(parse_object(sha1
), NULL
, 0);
88 return check_commit(obj
, sha1
, quiet
);
91 struct commit
*lookup_commit_reference(const unsigned char *sha1
)
93 return lookup_commit_reference_gently(sha1
, 0);
96 struct commit
*lookup_commit(const unsigned char *sha1
)
98 struct object
*obj
= lookup_object(sha1
);
100 struct commit
*ret
= alloc_commit_node();
101 created_object(sha1
, &ret
->object
);
102 ret
->object
.type
= OBJ_COMMIT
;
106 obj
->type
= OBJ_COMMIT
;
107 return check_commit(obj
, sha1
, 0);
110 static unsigned long parse_commit_date(const char *buf
)
114 if (memcmp(buf
, "author", 6))
116 while (*buf
++ != '\n')
118 if (memcmp(buf
, "committer", 9))
120 while (*buf
++ != '>')
122 date
= strtoul(buf
, NULL
, 10);
123 if (date
== ULONG_MAX
)
128 static struct commit_graft
**commit_graft
;
129 static int commit_graft_alloc
, commit_graft_nr
;
131 static int commit_graft_pos(const unsigned char *sha1
)
135 hi
= commit_graft_nr
;
137 int mi
= (lo
+ hi
) / 2;
138 struct commit_graft
*graft
= commit_graft
[mi
];
139 int cmp
= hashcmp(sha1
, graft
->sha1
);
150 int register_commit_graft(struct commit_graft
*graft
, int ignore_dups
)
152 int pos
= commit_graft_pos(graft
->sha1
);
158 free(commit_graft
[pos
]);
159 commit_graft
[pos
] = graft
;
164 if (commit_graft_alloc
<= ++commit_graft_nr
) {
165 commit_graft_alloc
= alloc_nr(commit_graft_alloc
);
166 commit_graft
= xrealloc(commit_graft
,
167 sizeof(*commit_graft
) *
170 if (pos
< commit_graft_nr
)
171 memmove(commit_graft
+ pos
+ 1,
173 (commit_graft_nr
- pos
- 1) *
174 sizeof(*commit_graft
));
175 commit_graft
[pos
] = graft
;
179 struct commit_graft
*read_graft_line(char *buf
, int len
)
181 /* The format is just "Commit Parent1 Parent2 ...\n" */
183 struct commit_graft
*graft
= NULL
;
185 if (buf
[len
-1] == '\n')
187 if (buf
[0] == '#' || buf
[0] == '\0')
189 if ((len
+ 1) % 41) {
191 error("bad graft data: %s", buf
);
195 i
= (len
+ 1) / 41 - 1;
196 graft
= xmalloc(sizeof(*graft
) + 20 * i
);
197 graft
->nr_parent
= i
;
198 if (get_sha1_hex(buf
, graft
->sha1
))
200 for (i
= 40; i
< len
; i
+= 41) {
203 if (get_sha1_hex(buf
+ i
+ 1, graft
->parent
[i
/41]))
209 int read_graft_file(const char *graft_file
)
211 FILE *fp
= fopen(graft_file
, "r");
215 while (fgets(buf
, sizeof(buf
), fp
)) {
216 /* The format is just "Commit Parent1 Parent2 ...\n" */
217 int len
= strlen(buf
);
218 struct commit_graft
*graft
= read_graft_line(buf
, len
);
221 if (register_commit_graft(graft
, 1))
222 error("duplicate graft data: %s", buf
);
228 static void prepare_commit_graft(void)
230 static int commit_graft_prepared
;
233 if (commit_graft_prepared
)
235 graft_file
= get_graft_file();
236 read_graft_file(graft_file
);
237 /* make sure shallows are read */
238 is_repository_shallow();
239 commit_graft_prepared
= 1;
242 static struct commit_graft
*lookup_commit_graft(const unsigned char *sha1
)
245 prepare_commit_graft();
246 pos
= commit_graft_pos(sha1
);
249 return commit_graft
[pos
];
252 int write_shallow_commits(int fd
, int use_pack_protocol
)
255 for (i
= 0; i
< commit_graft_nr
; i
++)
256 if (commit_graft
[i
]->nr_parent
< 0) {
258 sha1_to_hex(commit_graft
[i
]->sha1
);
260 if (use_pack_protocol
)
261 packet_write(fd
, "shallow %s", hex
);
263 if (write_in_full(fd
, hex
, 40) != 40)
265 if (write_in_full(fd
, "\n", 1) != 1)
272 int unregister_shallow(const unsigned char *sha1
)
274 int pos
= commit_graft_pos(sha1
);
277 if (pos
+ 1 < commit_graft_nr
)
278 memcpy(commit_graft
+ pos
, commit_graft
+ pos
+ 1,
279 sizeof(struct commit_graft
*)
280 * (commit_graft_nr
- pos
- 1));
285 int parse_commit_buffer(struct commit
*item
, void *buffer
, unsigned long size
)
288 char *bufptr
= buffer
;
289 unsigned char parent
[20];
290 struct commit_list
**pptr
;
291 struct commit_graft
*graft
;
294 if (item
->object
.parsed
)
296 item
->object
.parsed
= 1;
298 if (tail
<= bufptr
+ 5 || memcmp(bufptr
, "tree ", 5))
299 return error("bogus commit object %s", sha1_to_hex(item
->object
.sha1
));
300 if (tail
<= bufptr
+ 45 || get_sha1_hex(bufptr
+ 5, parent
) < 0)
301 return error("bad tree pointer in commit %s",
302 sha1_to_hex(item
->object
.sha1
));
303 item
->tree
= lookup_tree(parent
);
306 bufptr
+= 46; /* "tree " + "hex sha1" + "\n" */
307 pptr
= &item
->parents
;
309 graft
= lookup_commit_graft(item
->object
.sha1
);
310 while (bufptr
+ 48 < tail
&& !memcmp(bufptr
, "parent ", 7)) {
311 struct commit
*new_parent
;
313 if (tail
<= bufptr
+ 48 ||
314 get_sha1_hex(bufptr
+ 7, parent
) ||
316 return error("bad parents in commit %s", sha1_to_hex(item
->object
.sha1
));
320 new_parent
= lookup_commit(parent
);
322 pptr
= &commit_list_insert(new_parent
, pptr
)->next
;
328 struct commit
*new_parent
;
329 for (i
= 0; i
< graft
->nr_parent
; i
++) {
330 new_parent
= lookup_commit(graft
->parent
[i
]);
333 pptr
= &commit_list_insert(new_parent
, pptr
)->next
;
337 item
->date
= parse_commit_date(bufptr
);
339 if (track_object_refs
) {
341 struct commit_list
*p
;
342 struct object_refs
*refs
= alloc_object_refs(n_refs
);
344 refs
->ref
[i
++] = &item
->tree
->object
;
345 for (p
= item
->parents
; p
; p
= p
->next
)
346 refs
->ref
[i
++] = &p
->item
->object
;
347 set_object_refs(&item
->object
, refs
);
353 int parse_commit(struct commit
*item
)
355 enum object_type type
;
360 if (item
->object
.parsed
)
362 buffer
= read_sha1_file(item
->object
.sha1
, &type
, &size
);
364 return error("Could not read %s",
365 sha1_to_hex(item
->object
.sha1
));
366 if (type
!= OBJ_COMMIT
) {
368 return error("Object %s not a commit",
369 sha1_to_hex(item
->object
.sha1
));
371 ret
= parse_commit_buffer(item
, buffer
, size
);
372 if (save_commit_buffer
&& !ret
) {
373 item
->buffer
= buffer
;
380 struct commit_list
*commit_list_insert(struct commit
*item
, struct commit_list
**list_p
)
382 struct commit_list
*new_list
= xmalloc(sizeof(struct commit_list
));
383 new_list
->item
= item
;
384 new_list
->next
= *list_p
;
389 void free_commit_list(struct commit_list
*list
)
392 struct commit_list
*temp
= list
;
398 struct commit_list
* insert_by_date(struct commit
*item
, struct commit_list
**list
)
400 struct commit_list
**pp
= list
;
401 struct commit_list
*p
;
402 while ((p
= *pp
) != NULL
) {
403 if (p
->item
->date
< item
->date
) {
408 return commit_list_insert(item
, pp
);
412 void sort_by_date(struct commit_list
**list
)
414 struct commit_list
*ret
= NULL
;
416 insert_by_date((*list
)->item
, &ret
);
417 *list
= (*list
)->next
;
422 struct commit
*pop_most_recent_commit(struct commit_list
**list
,
425 struct commit
*ret
= (*list
)->item
;
426 struct commit_list
*parents
= ret
->parents
;
427 struct commit_list
*old
= *list
;
429 *list
= (*list
)->next
;
433 struct commit
*commit
= parents
->item
;
434 parse_commit(commit
);
435 if (!(commit
->object
.flags
& mark
)) {
436 commit
->object
.flags
|= mark
;
437 insert_by_date(commit
, list
);
439 parents
= parents
->next
;
444 void clear_commit_marks(struct commit
*commit
, unsigned int mark
)
446 struct commit_list
*parents
;
448 commit
->object
.flags
&= ~mark
;
449 parents
= commit
->parents
;
451 struct commit
*parent
= parents
->item
;
453 /* Have we already cleared this? */
454 if (mark
& parent
->object
.flags
)
455 clear_commit_marks(parent
, mark
);
456 parents
= parents
->next
;
461 * Generic support for pretty-printing the header
463 static int get_one_line(const char *msg
, unsigned long len
)
478 /* High bit set, or ISO-2022-INT */
479 static int non_ascii(int ch
)
482 return ((ch
& 0x80) || (ch
== 0x1b));
485 static int is_rfc2047_special(char ch
)
487 return (non_ascii(ch
) || (ch
== '=') || (ch
== '?') || (ch
== '_'));
490 static int add_rfc2047(char *buf
, const char *line
, int len
,
491 const char *encoding
)
495 char q_encoding
[128];
496 const char *q_encoding_fmt
= "=?%s?q?";
498 for (i
= needquote
= 0; !needquote
&& i
< len
; i
++) {
503 (ch
== '=' && line
[i
+1] == '?'))
507 return sprintf(buf
, "%.*s", len
, line
);
509 i
= snprintf(q_encoding
, sizeof(q_encoding
), q_encoding_fmt
, encoding
);
510 if (sizeof(q_encoding
) < i
)
511 die("Insanely long encoding name %s", encoding
);
512 memcpy(bp
, q_encoding
, i
);
514 for (i
= 0; i
< len
; i
++) {
515 unsigned ch
= line
[i
] & 0xFF;
516 if (is_rfc2047_special(ch
)) {
517 sprintf(bp
, "=%02X", ch
);
530 static int add_user_info(const char *what
, enum cmit_fmt fmt
, char *buf
,
531 const char *line
, int relative_date
,
532 const char *encoding
)
538 const char *filler
= " ";
540 if (fmt
== CMIT_FMT_ONELINE
)
542 date
= strchr(line
, '>');
545 namelen
= ++date
- line
;
546 time
= strtoul(date
, &date
, 10);
547 tz
= strtol(date
, NULL
, 10);
549 if (fmt
== CMIT_FMT_EMAIL
) {
550 char *name_tail
= strchr(line
, '<');
551 int display_name_length
;
554 while (line
< name_tail
&& isspace(name_tail
[-1]))
556 display_name_length
= name_tail
- line
;
558 strcpy(buf
, "From: ");
560 ret
+= add_rfc2047(buf
+ ret
, line
, display_name_length
,
562 memcpy(buf
+ ret
, name_tail
, namelen
- display_name_length
);
563 ret
+= namelen
- display_name_length
;
567 ret
= sprintf(buf
, "%s: %.*s%.*s\n", what
,
568 (fmt
== CMIT_FMT_FULLER
) ? 4 : 0,
569 filler
, namelen
, line
);
572 case CMIT_FMT_MEDIUM
:
573 ret
+= sprintf(buf
+ ret
, "Date: %s\n",
574 show_date(time
, tz
, relative_date
));
577 ret
+= sprintf(buf
+ ret
, "Date: %s\n",
578 show_rfc2822_date(time
, tz
));
580 case CMIT_FMT_FULLER
:
581 ret
+= sprintf(buf
+ ret
, "%sDate: %s\n", what
,
582 show_date(time
, tz
, relative_date
));
591 static int is_empty_line(const char *line
, int *len_p
)
594 while (len
&& isspace(line
[len
-1]))
600 static int add_merge_info(enum cmit_fmt fmt
, char *buf
, const struct commit
*commit
, int abbrev
)
602 struct commit_list
*parent
= commit
->parents
;
605 if ((fmt
== CMIT_FMT_ONELINE
) || (fmt
== CMIT_FMT_EMAIL
) ||
606 !parent
|| !parent
->next
)
609 offset
= sprintf(buf
, "Merge:");
612 struct commit
*p
= parent
->item
;
613 const char *hex
= NULL
;
616 hex
= find_unique_abbrev(p
->object
.sha1
, abbrev
);
618 hex
= sha1_to_hex(p
->object
.sha1
);
619 dots
= (abbrev
&& strlen(hex
) != 40) ? "..." : "";
620 parent
= parent
->next
;
622 offset
+= sprintf(buf
+ offset
, " %s%s", hex
, dots
);
624 buf
[offset
++] = '\n';
628 static char *get_header(const struct commit
*commit
, const char *key
)
630 int key_len
= strlen(key
);
631 const char *line
= commit
->buffer
;
634 const char *eol
= strchr(line
, '\n'), *next
;
639 eol
= line
+ strlen(line
);
643 if (!strncmp(line
, key
, key_len
) && line
[key_len
] == ' ') {
644 int len
= eol
- line
- key_len
;
645 char *ret
= xmalloc(len
);
646 memcpy(ret
, line
+ key_len
+ 1, len
- 1);
654 static char *replace_encoding_header(char *buf
, const char *encoding
)
656 char *encoding_header
= strstr(buf
, "\nencoding ");
657 char *end_of_encoding_header
;
658 int encoding_header_pos
;
659 int encoding_header_len
;
662 int buflen
= strlen(buf
) + 1;
664 if (!encoding_header
)
665 return buf
; /* should not happen but be defensive */
667 end_of_encoding_header
= strchr(encoding_header
, '\n');
668 if (!end_of_encoding_header
)
669 return buf
; /* should not happen but be defensive */
670 end_of_encoding_header
++;
672 encoding_header_len
= end_of_encoding_header
- encoding_header
;
673 encoding_header_pos
= encoding_header
- buf
;
675 if (is_encoding_utf8(encoding
)) {
676 /* we have re-coded to UTF-8; drop the header */
677 memmove(encoding_header
, end_of_encoding_header
,
678 buflen
- (encoding_header_pos
+ encoding_header_len
));
681 new_len
= strlen(encoding
);
682 need_len
= new_len
+ strlen("encoding \n");
683 if (encoding_header_len
< need_len
) {
684 buf
= xrealloc(buf
, buflen
+ (need_len
- encoding_header_len
));
685 encoding_header
= buf
+ encoding_header_pos
;
686 end_of_encoding_header
= encoding_header
+ encoding_header_len
;
688 memmove(end_of_encoding_header
+ (need_len
- encoding_header_len
),
689 end_of_encoding_header
,
690 buflen
- (encoding_header_pos
+ encoding_header_len
));
691 memcpy(encoding_header
+ 9, encoding
, strlen(encoding
));
692 encoding_header
[9 + new_len
] = '\n';
696 static char *logmsg_reencode(const struct commit
*commit
,
697 const char *output_encoding
)
699 static const char *utf8
= "utf-8";
700 const char *use_encoding
;
704 if (!*output_encoding
)
706 encoding
= get_header(commit
, "encoding");
707 use_encoding
= encoding
? encoding
: utf8
;
708 if (!strcmp(use_encoding
, output_encoding
))
709 out
= strdup(commit
->buffer
);
711 out
= reencode_string(commit
->buffer
,
712 output_encoding
, use_encoding
);
714 out
= replace_encoding_header(out
, output_encoding
);
720 static char *xstrndup(const char *text
, int len
)
722 char *result
= xmalloc(len
+ 1);
723 memcpy(result
, text
, len
);
728 static void fill_person(struct interp
*table
, const char *msg
, int len
)
730 int start
, end
, tz
= 0;
735 for (end
= 0; end
< len
&& msg
[end
] != '<'; end
++)
738 while (end
> 0 && isspace(msg
[end
- 1]))
740 table
[0].value
= xstrndup(msg
, end
);
746 for (end
= start
+ 1; end
< len
&& msg
[end
] != '>'; end
++)
752 table
[1].value
= xstrndup(msg
+ start
, end
- start
);
755 for (start
= end
+ 1; start
< len
&& isspace(msg
[start
]); start
++)
759 date
= strtoul(msg
+ start
, &ep
, 10);
760 if (msg
+ start
== ep
)
763 table
[5].value
= xstrndup(msg
+ start
, ep
- msg
+ start
);
766 for (start
= ep
- msg
+ 1; start
< len
&& isspace(msg
[start
]); start
++)
768 if (start
+ 1 < len
) {
769 tz
= strtoul(msg
+ start
+ 1, NULL
, 10);
770 if (msg
[start
] == '-')
774 interp_set_entry(table
, 2, show_date(date
, tz
, 0));
775 interp_set_entry(table
, 3, show_rfc2822_date(date
, tz
));
776 interp_set_entry(table
, 4, show_date(date
, tz
, 1));
779 static long format_commit_message(const struct commit
*commit
,
780 const char *msg
, char *buf
, unsigned long space
)
782 struct interp table
[] = {
783 { "%H" }, /* commit hash */
784 { "%h" }, /* abbreviated commit hash */
785 { "%T" }, /* tree hash */
786 { "%t" }, /* abbreviated tree hash */
787 { "%P" }, /* parent hashes */
788 { "%p" }, /* abbreviated parent hashes */
789 { "%an" }, /* author name */
790 { "%ae" }, /* author email */
791 { "%ad" }, /* author date */
792 { "%aD" }, /* author date, RFC2822 style */
793 { "%ar" }, /* author date, relative */
794 { "%at" }, /* author date, UNIX timestamp */
795 { "%cn" }, /* committer name */
796 { "%ce" }, /* committer email */
797 { "%cd" }, /* committer date */
798 { "%cD" }, /* committer date, RFC2822 style */
799 { "%cr" }, /* committer date, relative */
800 { "%ct" }, /* committer date, UNIX timestamp */
801 { "%e" }, /* encoding */
802 { "%s" }, /* subject */
804 { "%Cred" }, /* red */
805 { "%Cgreen" }, /* green */
806 { "%Cblue" }, /* blue */
807 { "%Creset" }, /* reset color */
808 { "%n" } /* newline */
811 IHASH
= 0, IHASH_ABBREV
,
813 IPARENTS
, IPARENTS_ABBREV
,
814 IAUTHOR_NAME
, IAUTHOR_EMAIL
,
815 IAUTHOR_DATE
, IAUTHOR_DATE_RFC2822
, IAUTHOR_DATE_RELATIVE
,
817 ICOMMITTER_NAME
, ICOMMITTER_EMAIL
,
818 ICOMMITTER_DATE
, ICOMMITTER_DATE_RFC2822
,
819 ICOMMITTER_DATE_RELATIVE
, ICOMMITTER_TIMESTAMP
,
823 IRED
, IGREEN
, IBLUE
, IRESET_COLOR
,
826 struct commit_list
*p
;
829 enum { HEADER
, SUBJECT
, BODY
} state
;
831 if (INEWLINE
+ 1 != ARRAY_SIZE(table
))
832 die("invalid interp table!");
834 /* these are independent of the commit */
835 interp_set_entry(table
, IRED
, "\033[31m");
836 interp_set_entry(table
, IGREEN
, "\033[32m");
837 interp_set_entry(table
, IBLUE
, "\033[34m");
838 interp_set_entry(table
, IRESET_COLOR
, "\033[m");
839 interp_set_entry(table
, INEWLINE
, "\n");
841 /* these depend on the commit */
842 if (!commit
->object
.parsed
)
843 parse_object(commit
->object
.sha1
);
844 interp_set_entry(table
, IHASH
, sha1_to_hex(commit
->object
.sha1
));
845 interp_set_entry(table
, IHASH_ABBREV
,
846 find_unique_abbrev(commit
->object
.sha1
,
848 interp_set_entry(table
, ITREE
, sha1_to_hex(commit
->tree
->object
.sha1
));
849 interp_set_entry(table
, ITREE_ABBREV
,
850 find_unique_abbrev(commit
->tree
->object
.sha1
,
852 for (i
= 0, p
= commit
->parents
;
853 p
&& i
< sizeof(parents
) - 1;
855 i
+= snprintf(parents
+ i
, sizeof(parents
) - i
- 1, "%s ",
856 sha1_to_hex(p
->item
->object
.sha1
));
857 interp_set_entry(table
, IPARENTS
, parents
);
858 for (i
= 0, p
= commit
->parents
;
859 p
&& i
< sizeof(parents
) - 1;
861 i
+= snprintf(parents
+ i
, sizeof(parents
) - i
- 1, "%s ",
862 find_unique_abbrev(p
->item
->object
.sha1
,
864 interp_set_entry(table
, IPARENTS_ABBREV
, parents
);
866 for (i
= 0, state
= HEADER
; msg
[i
] && state
< BODY
; i
++) {
868 for (eol
= i
; msg
[eol
] && msg
[eol
] != '\n'; eol
++)
871 if (state
== SUBJECT
) {
872 table
[ISUBJECT
].value
= xstrndup(msg
+ i
, eol
- i
);
877 /* strip empty lines */
878 while (msg
[eol
+ 1] == '\n')
880 } else if (!prefixcmp(msg
+ i
, "author "))
881 fill_person(table
+ IAUTHOR_NAME
,
882 msg
+ i
+ 7, eol
- i
- 7);
883 else if (!prefixcmp(msg
+ i
, "committer "))
884 fill_person(table
+ ICOMMITTER_NAME
,
885 msg
+ i
+ 10, eol
- i
- 10);
886 else if (!prefixcmp(msg
+ i
, "encoding "))
887 table
[IENCODING
].value
= xstrndup(msg
+ i
, eol
- i
);
891 table
[IBODY
].value
= xstrdup(msg
+ i
);
892 for (i
= 0; i
< ARRAY_SIZE(table
); i
++)
894 interp_set_entry(table
, i
, "<unknown>");
896 interpolate(buf
, space
, user_format
, table
, ARRAY_SIZE(table
));
897 interp_clear_table(table
, ARRAY_SIZE(table
));
902 unsigned long pretty_print_commit(enum cmit_fmt fmt
,
903 const struct commit
*commit
,
905 char *buf
, unsigned long space
,
906 int abbrev
, const char *subject
,
907 const char *after_subject
,
910 int hdr
= 1, body
= 0, seen_title
= 0;
911 unsigned long offset
= 0;
913 int parents_shown
= 0;
914 const char *msg
= commit
->buffer
;
915 int plain_non_ascii
= 0;
917 const char *encoding
;
919 if (fmt
== CMIT_FMT_USERFORMAT
)
920 return format_commit_message(commit
, msg
, buf
, space
);
922 encoding
= (git_log_output_encoding
923 ? git_log_output_encoding
924 : git_commit_encoding
);
927 reencoded
= logmsg_reencode(commit
, encoding
);
931 if (fmt
== CMIT_FMT_ONELINE
|| fmt
== CMIT_FMT_EMAIL
)
934 /* After-subject is used to pass in Content-Type: multipart
935 * MIME header; in that case we do not have to do the
936 * plaintext content type even if the commit message has
937 * non 7-bit ASCII character. Otherwise, check if we need
938 * to say this is not a 7-bit ASCII.
940 if (fmt
== CMIT_FMT_EMAIL
&& !after_subject
) {
943 for (in_body
= i
= 0; (ch
= msg
[i
]) && i
< len
; i
++) {
945 /* author could be non 7-bit ASCII but
946 * the log may be so; skip over the
950 i
+ 1 < len
&& msg
[i
+1] == '\n')
953 else if (non_ascii(ch
)) {
961 const char *line
= msg
;
962 int linelen
= get_one_line(msg
, len
);
968 * We want some slop for indentation and a possible
969 * final "...". Thus the "+ 20".
971 if (offset
+ linelen
+ 20 > space
) {
972 memcpy(buf
+ offset
, " ...\n", 8);
982 if ((fmt
!= CMIT_FMT_ONELINE
) && !subject
)
983 buf
[offset
++] = '\n';
986 if (fmt
== CMIT_FMT_RAW
) {
987 memcpy(buf
+ offset
, line
, linelen
);
991 if (!memcmp(line
, "parent ", 7)) {
993 die("bad parent line in commit");
997 if (!parents_shown
) {
998 offset
+= add_merge_info(fmt
, buf
+ offset
,
1004 * MEDIUM == DEFAULT shows only author with dates.
1005 * FULL shows both authors but not dates.
1006 * FULLER shows both authors and dates.
1008 if (!memcmp(line
, "author ", 7))
1009 offset
+= add_user_info("Author", fmt
,
1014 if (!memcmp(line
, "committer ", 10) &&
1015 (fmt
== CMIT_FMT_FULL
|| fmt
== CMIT_FMT_FULLER
))
1016 offset
+= add_user_info("Commit", fmt
,
1027 if (is_empty_line(line
, &linelen
)) {
1034 if (fmt
== CMIT_FMT_SHORT
)
1040 int slen
= strlen(subject
);
1041 memcpy(buf
+ offset
, subject
, slen
);
1043 offset
+= add_rfc2047(buf
+ offset
, line
, linelen
,
1047 memset(buf
+ offset
, ' ', indent
);
1048 memcpy(buf
+ offset
+ indent
, line
, linelen
);
1049 offset
+= linelen
+ indent
;
1051 buf
[offset
++] = '\n';
1052 if (fmt
== CMIT_FMT_ONELINE
)
1054 if (subject
&& plain_non_ascii
) {
1057 const char *header_fmt
=
1058 "Content-Type: text/plain; charset=%s\n"
1059 "Content-Transfer-Encoding: 8bit\n";
1060 sz
= snprintf(header
, sizeof(header
), header_fmt
,
1062 if (sizeof(header
) < sz
)
1063 die("Encoding name %s too long", encoding
);
1064 memcpy(buf
+ offset
, header
, sz
);
1067 if (after_subject
) {
1068 int slen
= strlen(after_subject
);
1069 if (slen
> space
- offset
- 1)
1070 slen
= space
- offset
- 1;
1071 memcpy(buf
+ offset
, after_subject
, slen
);
1073 after_subject
= NULL
;
1077 while (offset
&& isspace(buf
[offset
-1]))
1079 /* Make sure there is an EOLN for the non-oneline case */
1080 if (fmt
!= CMIT_FMT_ONELINE
)
1081 buf
[offset
++] = '\n';
1083 * make sure there is another EOLN to separate the headers from whatever
1084 * body the caller appends if we haven't already written a body
1086 if (fmt
== CMIT_FMT_EMAIL
&& !body
)
1087 buf
[offset
++] = '\n';
1094 struct commit
*pop_commit(struct commit_list
**stack
)
1096 struct commit_list
*top
= *stack
;
1097 struct commit
*item
= top
? top
->item
: NULL
;
1106 int count_parents(struct commit
* commit
)
1109 struct commit_list
* parents
= commit
->parents
;
1110 for (count
= 0; parents
; parents
= parents
->next
,count
++)
1115 void topo_sort_default_setter(struct commit
*c
, void *data
)
1120 void *topo_sort_default_getter(struct commit
*c
)
1126 * Performs an in-place topological sort on the list supplied.
1128 void sort_in_topological_order(struct commit_list
** list
, int lifo
)
1130 sort_in_topological_order_fn(list
, lifo
, topo_sort_default_setter
,
1131 topo_sort_default_getter
);
1134 void sort_in_topological_order_fn(struct commit_list
** list
, int lifo
,
1135 topo_sort_set_fn_t setter
,
1136 topo_sort_get_fn_t getter
)
1138 struct commit_list
* next
= *list
;
1139 struct commit_list
* work
= NULL
, **insert
;
1140 struct commit_list
** pptr
= list
;
1141 struct sort_node
* nodes
;
1142 struct sort_node
* next_nodes
;
1145 /* determine the size of the list */
1153 /* allocate an array to help sort the list */
1154 nodes
= xcalloc(count
, sizeof(*nodes
));
1155 /* link the list to the array */
1159 next_nodes
->list_item
= next
;
1160 setter(next
->item
, next_nodes
);
1164 /* update the indegree */
1167 struct commit_list
* parents
= next
->item
->parents
;
1169 struct commit
* parent
=parents
->item
;
1170 struct sort_node
* pn
= (struct sort_node
*) getter(parent
);
1174 parents
=parents
->next
;
1181 * tips are nodes not reachable from any other node in the list
1183 * the tips serve as a starting set for the work queue.
1188 struct sort_node
* node
= (struct sort_node
*) getter(next
->item
);
1190 if (node
->indegree
== 0) {
1191 insert
= &commit_list_insert(next
->item
, insert
)->next
;
1196 /* process the list in topological order */
1198 sort_by_date(&work
);
1200 struct commit
* work_item
= pop_commit(&work
);
1201 struct sort_node
* work_node
= (struct sort_node
*) getter(work_item
);
1202 struct commit_list
* parents
= work_item
->parents
;
1205 struct commit
* parent
=parents
->item
;
1206 struct sort_node
* pn
= (struct sort_node
*) getter(parent
);
1210 * parents are only enqueued for emission
1211 * when all their children have been emitted thereby
1212 * guaranteeing topological order.
1215 if (!pn
->indegree
) {
1217 insert_by_date(parent
, &work
);
1219 commit_list_insert(parent
, &work
);
1222 parents
=parents
->next
;
1225 * work_item is a commit all of whose children
1226 * have already been emitted. we can emit it now.
1228 *pptr
= work_node
->list_item
;
1229 pptr
= &(*pptr
)->next
;
1231 setter(work_item
, NULL
);
1236 /* merge-base stuff */
1238 /* bits #0..15 in revision.h */
1239 #define PARENT1 (1u<<16)
1240 #define PARENT2 (1u<<17)
1241 #define STALE (1u<<18)
1242 #define RESULT (1u<<19)
1244 static const unsigned all_flags
= (PARENT1
| PARENT2
| STALE
| RESULT
);
1246 static struct commit
*interesting(struct commit_list
*list
)
1249 struct commit
*commit
= list
->item
;
1251 if (commit
->object
.flags
& STALE
)
1258 static struct commit_list
*base_traverse(struct commit_list
*list
, struct commit
*stop
)
1260 struct commit_list
*result
= NULL
;
1262 while (interesting(list
)) {
1263 struct commit
*commit
;
1264 struct commit_list
*parents
;
1265 struct commit_list
*n
;
1268 commit
= list
->item
;
1273 flags
= commit
->object
.flags
& (PARENT1
| PARENT2
| STALE
);
1274 if (flags
== (PARENT1
| PARENT2
)) {
1275 if (!(commit
->object
.flags
& RESULT
)) {
1276 commit
->object
.flags
|= RESULT
;
1277 insert_by_date(commit
, &result
);
1279 /* Mark parents of a found merge stale */
1282 parents
= commit
->parents
;
1284 struct commit
*p
= parents
->item
;
1285 parents
= parents
->next
;
1286 if ((p
->object
.flags
& flags
) == flags
)
1289 p
->object
.flags
|= flags
;
1290 insert_by_date(p
, &list
);
1292 if (stop
&& (stop
->object
.flags
& PARENT2
)) {
1293 free_commit_list(list
);
1295 insert_by_date(stop
, &list
);
1300 /* Clean up the result to remove stale ones */
1301 free_commit_list(list
);
1306 list
= result
; result
= NULL
;
1308 struct commit_list
*n
= list
->next
;
1309 if (!(list
->item
->object
.flags
& STALE
))
1310 insert_by_date(list
->item
, &result
);
1317 static struct commit_list
*merge_bases(struct commit
*one
, struct commit
*two
)
1319 struct commit_list
*list
= NULL
;
1322 /* We do not mark this even with RESULT so we do not
1323 * have to clean it up.
1325 return commit_list_insert(one
, &list
);
1330 one
->object
.flags
|= PARENT1
;
1331 two
->object
.flags
|= PARENT2
;
1332 insert_by_date(one
, &list
);
1333 insert_by_date(two
, &list
);
1335 return base_traverse(list
, NULL
);
1338 struct commit_list
*get_merge_bases(struct commit
*one
,
1342 struct commit_list
*list
;
1343 struct commit
**rslt
;
1344 struct commit_list
*result
;
1347 result
= merge_bases(one
, two
);
1350 if (!result
|| !result
->next
) {
1352 clear_commit_marks(one
, all_flags
);
1353 clear_commit_marks(two
, all_flags
);
1358 /* There are more than one */
1365 rslt
= xcalloc(cnt
, sizeof(*rslt
));
1366 for (list
= result
, i
= 0; list
; list
= list
->next
)
1367 rslt
[i
++] = list
->item
;
1368 free_commit_list(result
);
1370 clear_commit_marks(one
, all_flags
);
1371 clear_commit_marks(two
, all_flags
);
1372 for (i
= 0; i
< cnt
- 1; i
++) {
1373 for (j
= i
+1; j
< cnt
; j
++) {
1374 if (!rslt
[i
] || !rslt
[j
])
1376 result
= merge_bases(rslt
[i
], rslt
[j
]);
1377 clear_commit_marks(rslt
[i
], all_flags
);
1378 clear_commit_marks(rslt
[j
], all_flags
);
1379 for (list
= result
; list
; list
= list
->next
) {
1380 if (rslt
[i
] == list
->item
)
1382 if (rslt
[j
] == list
->item
)
1388 /* Surviving ones in rslt[] are the independent results */
1390 for (i
= 0; i
< cnt
; i
++) {
1392 insert_by_date(rslt
[i
], &result
);
1398 int in_merge_bases(struct commit
*commit
, struct commit
**reference
, int num
)
1400 struct commit_list
*result
, *list
;
1404 parse_commit(commit
);
1405 commit
->object
.flags
|= PARENT1
;
1406 insert_by_date(commit
, &list
);
1408 for (i
= 0; i
< num
; i
++) {
1409 struct commit
*two
= reference
[i
];
1411 if (!(two
->object
.flags
& PARENT2
)) {
1412 two
->object
.flags
|= PARENT2
;
1413 insert_by_date(two
, &list
);
1416 result
= base_traverse(list
, commit
);
1418 free_commit_list(result
);
1420 clear_commit_marks(commit
, all_flags
);
1421 for (i
= 0; i
< num
; i
++) {
1422 struct commit
*two
= reference
[i
];
1423 clear_commit_marks(two
, all_flags
);