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
, unsigned long len
)
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 int add_rfc2047(char *buf
, const char *line
, int len
,
489 const char *encoding
)
493 char q_encoding
[128];
494 const char *q_encoding_fmt
= "=?%s?q?";
496 for (i
= needquote
= 0; !needquote
&& i
< len
; i
++) {
501 (ch
== '=' && line
[i
+1] == '?'))
505 return sprintf(buf
, "%.*s", len
, line
);
507 i
= snprintf(q_encoding
, sizeof(q_encoding
), q_encoding_fmt
, encoding
);
508 if (sizeof(q_encoding
) < i
)
509 die("Insanely long encoding name %s", encoding
);
510 memcpy(bp
, q_encoding
, i
);
512 for (i
= 0; i
< len
; i
++) {
513 unsigned ch
= line
[i
] & 0xFF;
515 * We encode ' ' using '=20' even though rfc2047
516 * allows using '_' for readability. Unfortunately,
517 * many programs do not understand this and just
518 * leave the underscore in place.
520 if (is_rfc2047_special(ch
) || ch
== ' ') {
521 sprintf(bp
, "=%02X", ch
);
532 static unsigned long bound_rfc2047(unsigned long len
, const char *encoding
)
534 /* upper bound of q encoded string of length 'len' */
535 unsigned long elen
= strlen(encoding
);
537 return len
* 3 + elen
+ 100;
540 static int add_user_info(const char *what
, enum cmit_fmt fmt
, char *buf
,
541 const char *line
, enum date_mode dmode
,
542 const char *encoding
)
548 const char *filler
= " ";
550 if (fmt
== CMIT_FMT_ONELINE
)
552 date
= strchr(line
, '>');
555 namelen
= ++date
- line
;
556 time
= strtoul(date
, &date
, 10);
557 tz
= strtol(date
, NULL
, 10);
559 if (fmt
== CMIT_FMT_EMAIL
) {
560 char *name_tail
= strchr(line
, '<');
561 int display_name_length
;
564 while (line
< name_tail
&& isspace(name_tail
[-1]))
566 display_name_length
= name_tail
- line
;
568 strcpy(buf
, "From: ");
570 ret
+= add_rfc2047(buf
+ ret
, line
, display_name_length
,
572 memcpy(buf
+ ret
, name_tail
, namelen
- display_name_length
);
573 ret
+= namelen
- display_name_length
;
577 ret
= sprintf(buf
, "%s: %.*s%.*s\n", what
,
578 (fmt
== CMIT_FMT_FULLER
) ? 4 : 0,
579 filler
, namelen
, line
);
582 case CMIT_FMT_MEDIUM
:
583 ret
+= sprintf(buf
+ ret
, "Date: %s\n",
584 show_date(time
, tz
, dmode
));
587 ret
+= sprintf(buf
+ ret
, "Date: %s\n",
588 show_rfc2822_date(time
, tz
));
590 case CMIT_FMT_FULLER
:
591 ret
+= sprintf(buf
+ ret
, "%sDate: %s\n", what
,
592 show_date(time
, tz
, dmode
));
601 static int is_empty_line(const char *line
, int *len_p
)
604 while (len
&& isspace(line
[len
-1]))
610 static int add_merge_info(enum cmit_fmt fmt
, char *buf
, const struct commit
*commit
, int abbrev
)
612 struct commit_list
*parent
= commit
->parents
;
615 if ((fmt
== CMIT_FMT_ONELINE
) || (fmt
== CMIT_FMT_EMAIL
) ||
616 !parent
|| !parent
->next
)
619 offset
= sprintf(buf
, "Merge:");
622 struct commit
*p
= parent
->item
;
623 const char *hex
= NULL
;
626 hex
= find_unique_abbrev(p
->object
.sha1
, abbrev
);
628 hex
= sha1_to_hex(p
->object
.sha1
);
629 dots
= (abbrev
&& strlen(hex
) != 40) ? "..." : "";
630 parent
= parent
->next
;
632 offset
+= sprintf(buf
+ offset
, " %s%s", hex
, dots
);
634 buf
[offset
++] = '\n';
638 static char *get_header(const struct commit
*commit
, const char *key
)
640 int key_len
= strlen(key
);
641 const char *line
= commit
->buffer
;
644 const char *eol
= strchr(line
, '\n'), *next
;
649 eol
= line
+ strlen(line
);
653 if (eol
- line
> key_len
&&
654 !strncmp(line
, key
, key_len
) &&
655 line
[key_len
] == ' ') {
656 int len
= eol
- line
- key_len
;
657 char *ret
= xmalloc(len
);
658 memcpy(ret
, line
+ key_len
+ 1, len
- 1);
666 static char *replace_encoding_header(char *buf
, const char *encoding
)
668 char *encoding_header
= strstr(buf
, "\nencoding ");
669 char *header_end
= strstr(buf
, "\n\n");
670 char *end_of_encoding_header
;
671 int encoding_header_pos
;
672 int encoding_header_len
;
675 int buflen
= strlen(buf
) + 1;
678 header_end
= buf
+ buflen
;
679 if (!encoding_header
|| encoding_header
>= header_end
)
682 end_of_encoding_header
= strchr(encoding_header
, '\n');
683 if (!end_of_encoding_header
)
684 return buf
; /* should not happen but be defensive */
685 end_of_encoding_header
++;
687 encoding_header_len
= end_of_encoding_header
- encoding_header
;
688 encoding_header_pos
= encoding_header
- buf
;
690 if (is_encoding_utf8(encoding
)) {
691 /* we have re-coded to UTF-8; drop the header */
692 memmove(encoding_header
, end_of_encoding_header
,
693 buflen
- (encoding_header_pos
+ encoding_header_len
));
696 new_len
= strlen(encoding
);
697 need_len
= new_len
+ strlen("encoding \n");
698 if (encoding_header_len
< need_len
) {
699 buf
= xrealloc(buf
, buflen
+ (need_len
- encoding_header_len
));
700 encoding_header
= buf
+ encoding_header_pos
;
701 end_of_encoding_header
= encoding_header
+ encoding_header_len
;
703 memmove(end_of_encoding_header
+ (need_len
- encoding_header_len
),
704 end_of_encoding_header
,
705 buflen
- (encoding_header_pos
+ encoding_header_len
));
706 memcpy(encoding_header
+ 9, encoding
, strlen(encoding
));
707 encoding_header
[9 + new_len
] = '\n';
711 static char *logmsg_reencode(const struct commit
*commit
,
712 const char *output_encoding
)
714 static const char *utf8
= "utf-8";
715 const char *use_encoding
;
719 if (!*output_encoding
)
721 encoding
= get_header(commit
, "encoding");
722 use_encoding
= encoding
? encoding
: utf8
;
723 if (!strcmp(use_encoding
, output_encoding
))
724 out
= xstrdup(commit
->buffer
);
726 out
= reencode_string(commit
->buffer
,
727 output_encoding
, use_encoding
);
729 out
= replace_encoding_header(out
, output_encoding
);
735 static void fill_person(struct interp
*table
, const char *msg
, int len
)
737 int start
, end
, tz
= 0;
742 for (end
= 0; end
< len
&& msg
[end
] != '<'; end
++)
745 while (end
> 0 && isspace(msg
[end
- 1]))
747 table
[0].value
= xstrndup(msg
, end
);
753 for (end
= start
+ 1; end
< len
&& msg
[end
] != '>'; end
++)
759 table
[1].value
= xstrndup(msg
+ start
, end
- start
);
762 for (start
= end
+ 1; start
< len
&& isspace(msg
[start
]); start
++)
766 date
= strtoul(msg
+ start
, &ep
, 10);
767 if (msg
+ start
== ep
)
770 table
[5].value
= xstrndup(msg
+ start
, ep
- (msg
+ start
));
773 for (start
= ep
- msg
+ 1; start
< len
&& isspace(msg
[start
]); start
++)
775 if (start
+ 1 < len
) {
776 tz
= strtoul(msg
+ start
+ 1, NULL
, 10);
777 if (msg
[start
] == '-')
781 interp_set_entry(table
, 2, show_date(date
, tz
, 0));
782 interp_set_entry(table
, 3, show_rfc2822_date(date
, tz
));
783 interp_set_entry(table
, 4, show_date(date
, tz
, 1));
784 interp_set_entry(table
, 6, show_date(date
, tz
, DATE_ISO8601
));
787 static long format_commit_message(const struct commit
*commit
,
788 const char *msg
, char **buf_p
, unsigned long *space_p
)
790 struct interp table
[] = {
791 { "%H" }, /* commit hash */
792 { "%h" }, /* abbreviated commit hash */
793 { "%T" }, /* tree hash */
794 { "%t" }, /* abbreviated tree hash */
795 { "%P" }, /* parent hashes */
796 { "%p" }, /* abbreviated parent hashes */
797 { "%an" }, /* author name */
798 { "%ae" }, /* author email */
799 { "%ad" }, /* author date */
800 { "%aD" }, /* author date, RFC2822 style */
801 { "%ar" }, /* author date, relative */
802 { "%at" }, /* author date, UNIX timestamp */
803 { "%ai" }, /* author date, ISO 8601 */
804 { "%cn" }, /* committer name */
805 { "%ce" }, /* committer email */
806 { "%cd" }, /* committer date */
807 { "%cD" }, /* committer date, RFC2822 style */
808 { "%cr" }, /* committer date, relative */
809 { "%ct" }, /* committer date, UNIX timestamp */
810 { "%ci" }, /* committer date, ISO 8601 */
811 { "%e" }, /* encoding */
812 { "%s" }, /* subject */
814 { "%Cred" }, /* red */
815 { "%Cgreen" }, /* green */
816 { "%Cblue" }, /* blue */
817 { "%Creset" }, /* reset color */
818 { "%n" }, /* newline */
819 { "%m" }, /* left/right/bottom */
822 IHASH
= 0, IHASH_ABBREV
,
824 IPARENTS
, IPARENTS_ABBREV
,
825 IAUTHOR_NAME
, IAUTHOR_EMAIL
,
826 IAUTHOR_DATE
, IAUTHOR_DATE_RFC2822
, IAUTHOR_DATE_RELATIVE
,
827 IAUTHOR_TIMESTAMP
, IAUTHOR_ISO8601
,
828 ICOMMITTER_NAME
, ICOMMITTER_EMAIL
,
829 ICOMMITTER_DATE
, ICOMMITTER_DATE_RFC2822
,
830 ICOMMITTER_DATE_RELATIVE
, ICOMMITTER_TIMESTAMP
,
835 IRED
, IGREEN
, IBLUE
, IRESET_COLOR
,
839 struct commit_list
*p
;
842 enum { HEADER
, SUBJECT
, BODY
} state
;
844 if (ILEFT_RIGHT
+ 1 != ARRAY_SIZE(table
))
845 die("invalid interp table!");
847 /* these are independent of the commit */
848 interp_set_entry(table
, IRED
, "\033[31m");
849 interp_set_entry(table
, IGREEN
, "\033[32m");
850 interp_set_entry(table
, IBLUE
, "\033[34m");
851 interp_set_entry(table
, IRESET_COLOR
, "\033[m");
852 interp_set_entry(table
, INEWLINE
, "\n");
854 /* these depend on the commit */
855 if (!commit
->object
.parsed
)
856 parse_object(commit
->object
.sha1
);
857 interp_set_entry(table
, IHASH
, sha1_to_hex(commit
->object
.sha1
));
858 interp_set_entry(table
, IHASH_ABBREV
,
859 find_unique_abbrev(commit
->object
.sha1
,
861 interp_set_entry(table
, ITREE
, sha1_to_hex(commit
->tree
->object
.sha1
));
862 interp_set_entry(table
, ITREE_ABBREV
,
863 find_unique_abbrev(commit
->tree
->object
.sha1
,
865 interp_set_entry(table
, ILEFT_RIGHT
,
866 (commit
->object
.flags
& BOUNDARY
)
868 : (commit
->object
.flags
& SYMMETRIC_LEFT
)
873 for (i
= 0, p
= commit
->parents
;
874 p
&& i
< sizeof(parents
) - 1;
876 i
+= snprintf(parents
+ i
, sizeof(parents
) - i
- 1, " %s",
877 sha1_to_hex(p
->item
->object
.sha1
));
878 interp_set_entry(table
, IPARENTS
, parents
+ 1);
881 for (i
= 0, p
= commit
->parents
;
882 p
&& i
< sizeof(parents
) - 1;
884 i
+= snprintf(parents
+ i
, sizeof(parents
) - i
- 1, " %s",
885 find_unique_abbrev(p
->item
->object
.sha1
,
887 interp_set_entry(table
, IPARENTS_ABBREV
, parents
+ 1);
889 for (i
= 0, state
= HEADER
; msg
[i
] && state
< BODY
; i
++) {
891 for (eol
= i
; msg
[eol
] && msg
[eol
] != '\n'; eol
++)
894 if (state
== SUBJECT
) {
895 table
[ISUBJECT
].value
= xstrndup(msg
+ i
, eol
- i
);
900 /* strip empty lines */
901 while (msg
[eol
+ 1] == '\n')
903 } else if (!prefixcmp(msg
+ i
, "author "))
904 fill_person(table
+ IAUTHOR_NAME
,
905 msg
+ i
+ 7, eol
- i
- 7);
906 else if (!prefixcmp(msg
+ i
, "committer "))
907 fill_person(table
+ ICOMMITTER_NAME
,
908 msg
+ i
+ 10, eol
- i
- 10);
909 else if (!prefixcmp(msg
+ i
, "encoding "))
910 table
[IENCODING
].value
=
911 xstrndup(msg
+ i
+ 9, eol
- i
- 9);
915 table
[IBODY
].value
= xstrdup(msg
+ i
);
916 for (i
= 0; i
< ARRAY_SIZE(table
); i
++)
918 interp_set_entry(table
, i
, "<unknown>");
922 unsigned long space
= *space_p
;
924 space
= interpolate(buf
, space
, user_format
,
925 table
, ARRAY_SIZE(table
));
928 buf
= xrealloc(buf
, space
);
932 interp_clear_table(table
, ARRAY_SIZE(table
));
934 return strlen(*buf_p
);
937 static void pp_header(enum cmit_fmt fmt
,
939 enum date_mode dmode
,
940 const char *encoding
,
941 const struct commit
*commit
,
943 unsigned long *len_p
,
944 unsigned long *ofs_p
,
946 unsigned long *space_p
)
948 int parents_shown
= 0;
951 const char *line
= *msg_p
;
953 int linelen
= get_one_line(*msg_p
, *len_p
);
965 ALLOC_GROW(*buf_p
, linelen
+ *ofs_p
+ 20, *space_p
);
966 dst
= *buf_p
+ *ofs_p
;
968 if (fmt
== CMIT_FMT_RAW
) {
969 memcpy(dst
, line
, linelen
);
974 if (!memcmp(line
, "parent ", 7)) {
976 die("bad parent line in commit");
980 if (!parents_shown
) {
981 struct commit_list
*parent
;
983 for (parent
= commit
->parents
, num
= 0;
985 parent
= parent
->next
, num
++)
987 /* with enough slop */
988 num
= *ofs_p
+ num
* 50 + 20;
989 ALLOC_GROW(*buf_p
, num
, *space_p
);
990 dst
= *buf_p
+ *ofs_p
;
991 *ofs_p
+= add_merge_info(fmt
, dst
, commit
, abbrev
);
996 * MEDIUM == DEFAULT shows only author with dates.
997 * FULL shows both authors but not dates.
998 * FULLER shows both authors and dates.
1000 if (!memcmp(line
, "author ", 7)) {
1002 if (fmt
== CMIT_FMT_EMAIL
)
1003 len
= bound_rfc2047(linelen
, encoding
);
1004 ALLOC_GROW(*buf_p
, *ofs_p
+ len
+ 80, *space_p
);
1005 dst
= *buf_p
+ *ofs_p
;
1006 *ofs_p
+= add_user_info("Author", fmt
, dst
,
1007 line
+ 7, dmode
, encoding
);
1010 if (!memcmp(line
, "committer ", 10) &&
1011 (fmt
== CMIT_FMT_FULL
|| fmt
== CMIT_FMT_FULLER
)) {
1013 if (fmt
== CMIT_FMT_EMAIL
)
1014 len
= bound_rfc2047(linelen
, encoding
);
1015 ALLOC_GROW(*buf_p
, *ofs_p
+ len
+ 80, *space_p
);
1016 dst
= *buf_p
+ *ofs_p
;
1017 *ofs_p
+= add_user_info("Commit", fmt
, dst
,
1018 line
+ 10, dmode
, encoding
);
1023 static void pp_title_line(enum cmit_fmt fmt
,
1025 unsigned long *len_p
,
1026 unsigned long *ofs_p
,
1028 unsigned long *space_p
,
1030 const char *subject
,
1031 const char *after_subject
,
1032 const char *encoding
,
1033 int plain_non_ascii
)
1036 unsigned long title_alloc
, title_len
;
1041 title
= xmalloc(title_alloc
);
1043 const char *line
= *msg_p
;
1044 int linelen
= get_one_line(line
, *len_p
);
1048 if (!linelen
|| is_empty_line(line
, &linelen
))
1051 if (title_alloc
<= title_len
+ linelen
+ 2) {
1052 title_alloc
= title_len
+ linelen
+ 80;
1053 title
= xrealloc(title
, title_alloc
);
1057 if (fmt
== CMIT_FMT_EMAIL
) {
1059 title
[title_len
++] = '\n';
1062 title
[title_len
++] = ' ';
1064 memcpy(title
+ title_len
, line
, linelen
);
1065 title_len
+= linelen
;
1068 /* Enough slop for the MIME header and rfc2047 */
1069 len
= bound_rfc2047(title_len
, encoding
)+ 1000;
1071 len
+= strlen(subject
);
1073 len
+= strlen(after_subject
);
1075 len
+= strlen(encoding
);
1076 ALLOC_GROW(*buf_p
, title_len
+ *ofs_p
+ len
, *space_p
);
1079 len
= strlen(subject
);
1080 memcpy(*buf_p
+ *ofs_p
, subject
, len
);
1082 *ofs_p
+= add_rfc2047(*buf_p
+ *ofs_p
,
1083 title
, title_len
, encoding
);
1085 memcpy(*buf_p
+ *ofs_p
, title
, title_len
);
1086 *ofs_p
+= title_len
;
1088 (*buf_p
)[(*ofs_p
)++] = '\n';
1089 if (plain_non_ascii
) {
1090 const char *header_fmt
=
1091 "MIME-Version: 1.0\n"
1092 "Content-Type: text/plain; charset=%s\n"
1093 "Content-Transfer-Encoding: 8bit\n";
1094 *ofs_p
+= snprintf(*buf_p
+ *ofs_p
,
1096 header_fmt
, encoding
);
1098 if (after_subject
) {
1099 len
= strlen(after_subject
);
1100 memcpy(*buf_p
+ *ofs_p
, after_subject
, len
);
1104 if (fmt
== CMIT_FMT_EMAIL
) {
1105 ALLOC_GROW(*buf_p
, *ofs_p
+ 20, *space_p
);
1106 (*buf_p
)[(*ofs_p
)++] = '\n';
1110 static void pp_remainder(enum cmit_fmt fmt
,
1112 unsigned long *len_p
,
1113 unsigned long *ofs_p
,
1115 unsigned long *space_p
,
1120 const char *line
= *msg_p
;
1121 int linelen
= get_one_line(line
, *len_p
);
1128 if (is_empty_line(line
, &linelen
)) {
1131 if (fmt
== CMIT_FMT_SHORT
)
1136 ALLOC_GROW(*buf_p
, *ofs_p
+ linelen
+ indent
+ 20, *space_p
);
1138 memset(*buf_p
+ *ofs_p
, ' ', indent
);
1141 memcpy(*buf_p
+ *ofs_p
, line
, linelen
);
1143 (*buf_p
)[(*ofs_p
)++] = '\n';
1147 unsigned long pretty_print_commit(enum cmit_fmt fmt
,
1148 const struct commit
*commit
,
1150 char **buf_p
, unsigned long *space_p
,
1151 int abbrev
, const char *subject
,
1152 const char *after_subject
,
1153 enum date_mode dmode
)
1155 unsigned long offset
= 0;
1156 unsigned long beginning_of_body
;
1158 const char *msg
= commit
->buffer
;
1159 int plain_non_ascii
= 0;
1161 const char *encoding
;
1164 if (fmt
== CMIT_FMT_USERFORMAT
)
1165 return format_commit_message(commit
, msg
, buf_p
, space_p
);
1167 encoding
= (git_log_output_encoding
1168 ? git_log_output_encoding
1169 : git_commit_encoding
);
1172 reencoded
= logmsg_reencode(commit
, encoding
);
1175 len
= strlen(reencoded
);
1178 if (fmt
== CMIT_FMT_ONELINE
|| fmt
== CMIT_FMT_EMAIL
)
1181 /* After-subject is used to pass in Content-Type: multipart
1182 * MIME header; in that case we do not have to do the
1183 * plaintext content type even if the commit message has
1184 * non 7-bit ASCII character. Otherwise, check if we need
1185 * to say this is not a 7-bit ASCII.
1187 if (fmt
== CMIT_FMT_EMAIL
&& !after_subject
) {
1190 for (in_body
= i
= 0; (ch
= msg
[i
]) && i
< len
; i
++) {
1192 /* author could be non 7-bit ASCII but
1193 * the log may be so; skip over the
1194 * header part first.
1197 i
+ 1 < len
&& msg
[i
+1] == '\n')
1200 else if (non_ascii(ch
)) {
1201 plain_non_ascii
= 1;
1207 pp_header(fmt
, abbrev
, dmode
, encoding
,
1209 &offset
, buf_p
, space_p
);
1210 if (fmt
!= CMIT_FMT_ONELINE
&& !subject
) {
1211 ALLOC_GROW(*buf_p
, offset
+ 20, *space_p
);
1212 (*buf_p
)[offset
++] = '\n';
1215 /* Skip excess blank lines at the beginning of body, if any... */
1217 int linelen
= get_one_line(msg
, len
);
1221 if (!is_empty_line(msg
, &ll
))
1227 /* These formats treat the title line specially. */
1228 if (fmt
== CMIT_FMT_ONELINE
1229 || fmt
== CMIT_FMT_EMAIL
)
1230 pp_title_line(fmt
, &msg
, &len
, &offset
,
1231 buf_p
, space_p
, indent
,
1232 subject
, after_subject
, encoding
,
1235 beginning_of_body
= offset
;
1236 if (fmt
!= CMIT_FMT_ONELINE
)
1237 pp_remainder(fmt
, &msg
, &len
, &offset
,
1238 buf_p
, space_p
, indent
);
1240 while (offset
&& isspace((*buf_p
)[offset
-1]))
1243 ALLOC_GROW(*buf_p
, offset
+ 20, *space_p
);
1246 /* Make sure there is an EOLN for the non-oneline case */
1247 if (fmt
!= CMIT_FMT_ONELINE
)
1248 buf
[offset
++] = '\n';
1251 * The caller may append additional body text in e-mail
1252 * format. Make sure we did not strip the blank line
1253 * between the header and the body.
1255 if (fmt
== CMIT_FMT_EMAIL
&& offset
<= beginning_of_body
)
1256 buf
[offset
++] = '\n';
1262 struct commit
*pop_commit(struct commit_list
**stack
)
1264 struct commit_list
*top
= *stack
;
1265 struct commit
*item
= top
? top
->item
: NULL
;
1274 void topo_sort_default_setter(struct commit
*c
, void *data
)
1279 void *topo_sort_default_getter(struct commit
*c
)
1285 * Performs an in-place topological sort on the list supplied.
1287 void sort_in_topological_order(struct commit_list
** list
, int lifo
)
1289 sort_in_topological_order_fn(list
, lifo
, topo_sort_default_setter
,
1290 topo_sort_default_getter
);
1293 void sort_in_topological_order_fn(struct commit_list
** list
, int lifo
,
1294 topo_sort_set_fn_t setter
,
1295 topo_sort_get_fn_t getter
)
1297 struct commit_list
* next
= *list
;
1298 struct commit_list
* work
= NULL
, **insert
;
1299 struct commit_list
** pptr
= list
;
1300 struct sort_node
* nodes
;
1301 struct sort_node
* next_nodes
;
1304 /* determine the size of the list */
1312 /* allocate an array to help sort the list */
1313 nodes
= xcalloc(count
, sizeof(*nodes
));
1314 /* link the list to the array */
1318 next_nodes
->list_item
= next
;
1319 setter(next
->item
, next_nodes
);
1323 /* update the indegree */
1326 struct commit_list
* parents
= next
->item
->parents
;
1328 struct commit
* parent
=parents
->item
;
1329 struct sort_node
* pn
= (struct sort_node
*) getter(parent
);
1333 parents
=parents
->next
;
1340 * tips are nodes not reachable from any other node in the list
1342 * the tips serve as a starting set for the work queue.
1347 struct sort_node
* node
= (struct sort_node
*) getter(next
->item
);
1349 if (node
->indegree
== 0) {
1350 insert
= &commit_list_insert(next
->item
, insert
)->next
;
1355 /* process the list in topological order */
1357 sort_by_date(&work
);
1359 struct commit
* work_item
= pop_commit(&work
);
1360 struct sort_node
* work_node
= (struct sort_node
*) getter(work_item
);
1361 struct commit_list
* parents
= work_item
->parents
;
1364 struct commit
* parent
=parents
->item
;
1365 struct sort_node
* pn
= (struct sort_node
*) getter(parent
);
1369 * parents are only enqueued for emission
1370 * when all their children have been emitted thereby
1371 * guaranteeing topological order.
1374 if (!pn
->indegree
) {
1376 insert_by_date(parent
, &work
);
1378 commit_list_insert(parent
, &work
);
1381 parents
=parents
->next
;
1384 * work_item is a commit all of whose children
1385 * have already been emitted. we can emit it now.
1387 *pptr
= work_node
->list_item
;
1388 pptr
= &(*pptr
)->next
;
1390 setter(work_item
, NULL
);
1395 /* merge-base stuff */
1397 /* bits #0..15 in revision.h */
1398 #define PARENT1 (1u<<16)
1399 #define PARENT2 (1u<<17)
1400 #define STALE (1u<<18)
1401 #define RESULT (1u<<19)
1403 static const unsigned all_flags
= (PARENT1
| PARENT2
| STALE
| RESULT
);
1405 static struct commit
*interesting(struct commit_list
*list
)
1408 struct commit
*commit
= list
->item
;
1410 if (commit
->object
.flags
& STALE
)
1417 static struct commit_list
*merge_bases(struct commit
*one
, struct commit
*two
)
1419 struct commit_list
*list
= NULL
;
1420 struct commit_list
*result
= NULL
;
1423 /* We do not mark this even with RESULT so we do not
1424 * have to clean it up.
1426 return commit_list_insert(one
, &result
);
1431 one
->object
.flags
|= PARENT1
;
1432 two
->object
.flags
|= PARENT2
;
1433 insert_by_date(one
, &list
);
1434 insert_by_date(two
, &list
);
1436 while (interesting(list
)) {
1437 struct commit
*commit
;
1438 struct commit_list
*parents
;
1439 struct commit_list
*n
;
1442 commit
= list
->item
;
1447 flags
= commit
->object
.flags
& (PARENT1
| PARENT2
| STALE
);
1448 if (flags
== (PARENT1
| PARENT2
)) {
1449 if (!(commit
->object
.flags
& RESULT
)) {
1450 commit
->object
.flags
|= RESULT
;
1451 insert_by_date(commit
, &result
);
1453 /* Mark parents of a found merge stale */
1456 parents
= commit
->parents
;
1458 struct commit
*p
= parents
->item
;
1459 parents
= parents
->next
;
1460 if ((p
->object
.flags
& flags
) == flags
)
1463 p
->object
.flags
|= flags
;
1464 insert_by_date(p
, &list
);
1468 /* Clean up the result to remove stale ones */
1469 free_commit_list(list
);
1470 list
= result
; result
= NULL
;
1472 struct commit_list
*n
= list
->next
;
1473 if (!(list
->item
->object
.flags
& STALE
))
1474 insert_by_date(list
->item
, &result
);
1481 struct commit_list
*get_merge_bases(struct commit
*one
,
1485 struct commit_list
*list
;
1486 struct commit
**rslt
;
1487 struct commit_list
*result
;
1490 result
= merge_bases(one
, two
);
1493 if (!result
|| !result
->next
) {
1495 clear_commit_marks(one
, all_flags
);
1496 clear_commit_marks(two
, all_flags
);
1501 /* There are more than one */
1508 rslt
= xcalloc(cnt
, sizeof(*rslt
));
1509 for (list
= result
, i
= 0; list
; list
= list
->next
)
1510 rslt
[i
++] = list
->item
;
1511 free_commit_list(result
);
1513 clear_commit_marks(one
, all_flags
);
1514 clear_commit_marks(two
, all_flags
);
1515 for (i
= 0; i
< cnt
- 1; i
++) {
1516 for (j
= i
+1; j
< cnt
; j
++) {
1517 if (!rslt
[i
] || !rslt
[j
])
1519 result
= merge_bases(rslt
[i
], rslt
[j
]);
1520 clear_commit_marks(rslt
[i
], all_flags
);
1521 clear_commit_marks(rslt
[j
], all_flags
);
1522 for (list
= result
; list
; list
= list
->next
) {
1523 if (rslt
[i
] == list
->item
)
1525 if (rslt
[j
] == list
->item
)
1531 /* Surviving ones in rslt[] are the independent results */
1533 for (i
= 0; i
< cnt
; i
++) {
1535 insert_by_date(rslt
[i
], &result
);
1541 int in_merge_bases(struct commit
*commit
, struct commit
**reference
, int num
)
1543 struct commit_list
*bases
, *b
;
1547 bases
= get_merge_bases(commit
, *reference
, 1);
1550 for (b
= bases
; b
; b
= b
->next
) {
1551 if (!hashcmp(commit
->object
.sha1
, b
->item
->object
.sha1
)) {
1557 free_commit_list(bases
);