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";
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));
786 static long format_commit_message(const struct commit
*commit
,
787 const char *msg
, char **buf_p
, unsigned long *space_p
)
789 struct interp table
[] = {
790 { "%H" }, /* commit hash */
791 { "%h" }, /* abbreviated commit hash */
792 { "%T" }, /* tree hash */
793 { "%t" }, /* abbreviated tree hash */
794 { "%P" }, /* parent hashes */
795 { "%p" }, /* abbreviated parent hashes */
796 { "%an" }, /* author name */
797 { "%ae" }, /* author email */
798 { "%ad" }, /* author date */
799 { "%aD" }, /* author date, RFC2822 style */
800 { "%ar" }, /* author date, relative */
801 { "%at" }, /* author date, UNIX timestamp */
802 { "%cn" }, /* committer name */
803 { "%ce" }, /* committer email */
804 { "%cd" }, /* committer date */
805 { "%cD" }, /* committer date, RFC2822 style */
806 { "%cr" }, /* committer date, relative */
807 { "%ct" }, /* committer date, UNIX timestamp */
808 { "%e" }, /* encoding */
809 { "%s" }, /* subject */
811 { "%Cred" }, /* red */
812 { "%Cgreen" }, /* green */
813 { "%Cblue" }, /* blue */
814 { "%Creset" }, /* reset color */
815 { "%n" }, /* newline */
816 { "%m" }, /* left/right/bottom */
819 IHASH
= 0, IHASH_ABBREV
,
821 IPARENTS
, IPARENTS_ABBREV
,
822 IAUTHOR_NAME
, IAUTHOR_EMAIL
,
823 IAUTHOR_DATE
, IAUTHOR_DATE_RFC2822
, IAUTHOR_DATE_RELATIVE
,
825 ICOMMITTER_NAME
, ICOMMITTER_EMAIL
,
826 ICOMMITTER_DATE
, ICOMMITTER_DATE_RFC2822
,
827 ICOMMITTER_DATE_RELATIVE
, ICOMMITTER_TIMESTAMP
,
831 IRED
, IGREEN
, IBLUE
, IRESET_COLOR
,
835 struct commit_list
*p
;
838 enum { HEADER
, SUBJECT
, BODY
} state
;
840 if (ILEFT_RIGHT
+ 1 != ARRAY_SIZE(table
))
841 die("invalid interp table!");
843 /* these are independent of the commit */
844 interp_set_entry(table
, IRED
, "\033[31m");
845 interp_set_entry(table
, IGREEN
, "\033[32m");
846 interp_set_entry(table
, IBLUE
, "\033[34m");
847 interp_set_entry(table
, IRESET_COLOR
, "\033[m");
848 interp_set_entry(table
, INEWLINE
, "\n");
850 /* these depend on the commit */
851 if (!commit
->object
.parsed
)
852 parse_object(commit
->object
.sha1
);
853 interp_set_entry(table
, IHASH
, sha1_to_hex(commit
->object
.sha1
));
854 interp_set_entry(table
, IHASH_ABBREV
,
855 find_unique_abbrev(commit
->object
.sha1
,
857 interp_set_entry(table
, ITREE
, sha1_to_hex(commit
->tree
->object
.sha1
));
858 interp_set_entry(table
, ITREE_ABBREV
,
859 find_unique_abbrev(commit
->tree
->object
.sha1
,
861 interp_set_entry(table
, ILEFT_RIGHT
,
862 (commit
->object
.flags
& BOUNDARY
)
864 : (commit
->object
.flags
& SYMMETRIC_LEFT
)
869 for (i
= 0, p
= commit
->parents
;
870 p
&& i
< sizeof(parents
) - 1;
872 i
+= snprintf(parents
+ i
, sizeof(parents
) - i
- 1, " %s",
873 sha1_to_hex(p
->item
->object
.sha1
));
874 interp_set_entry(table
, IPARENTS
, parents
+ 1);
877 for (i
= 0, p
= commit
->parents
;
878 p
&& i
< sizeof(parents
) - 1;
880 i
+= snprintf(parents
+ i
, sizeof(parents
) - i
- 1, " %s",
881 find_unique_abbrev(p
->item
->object
.sha1
,
883 interp_set_entry(table
, IPARENTS_ABBREV
, parents
+ 1);
885 for (i
= 0, state
= HEADER
; msg
[i
] && state
< BODY
; i
++) {
887 for (eol
= i
; msg
[eol
] && msg
[eol
] != '\n'; eol
++)
890 if (state
== SUBJECT
) {
891 table
[ISUBJECT
].value
= xstrndup(msg
+ i
, eol
- i
);
896 /* strip empty lines */
897 while (msg
[eol
+ 1] == '\n')
899 } else if (!prefixcmp(msg
+ i
, "author "))
900 fill_person(table
+ IAUTHOR_NAME
,
901 msg
+ i
+ 7, eol
- i
- 7);
902 else if (!prefixcmp(msg
+ i
, "committer "))
903 fill_person(table
+ ICOMMITTER_NAME
,
904 msg
+ i
+ 10, eol
- i
- 10);
905 else if (!prefixcmp(msg
+ i
, "encoding "))
906 table
[IENCODING
].value
=
907 xstrndup(msg
+ i
+ 9, eol
- i
- 9);
911 table
[IBODY
].value
= xstrdup(msg
+ i
);
912 for (i
= 0; i
< ARRAY_SIZE(table
); i
++)
914 interp_set_entry(table
, i
, "<unknown>");
918 unsigned long space
= *space_p
;
920 space
= interpolate(buf
, space
, user_format
,
921 table
, ARRAY_SIZE(table
));
924 buf
= xrealloc(buf
, space
);
928 interp_clear_table(table
, ARRAY_SIZE(table
));
930 return strlen(*buf_p
);
933 static void pp_header(enum cmit_fmt fmt
,
935 enum date_mode dmode
,
936 const char *encoding
,
937 const struct commit
*commit
,
939 unsigned long *len_p
,
940 unsigned long *ofs_p
,
942 unsigned long *space_p
)
944 int parents_shown
= 0;
947 const char *line
= *msg_p
;
949 int linelen
= get_one_line(*msg_p
, *len_p
);
961 ALLOC_GROW(*buf_p
, linelen
+ *ofs_p
+ 20, *space_p
);
962 dst
= *buf_p
+ *ofs_p
;
964 if (fmt
== CMIT_FMT_RAW
) {
965 memcpy(dst
, line
, linelen
);
970 if (!memcmp(line
, "parent ", 7)) {
972 die("bad parent line in commit");
976 if (!parents_shown
) {
977 struct commit_list
*parent
;
979 for (parent
= commit
->parents
, num
= 0;
981 parent
= parent
->next
, num
++)
983 /* with enough slop */
984 num
= *ofs_p
+ num
* 50 + 20;
985 ALLOC_GROW(*buf_p
, num
, *space_p
);
986 dst
= *buf_p
+ *ofs_p
;
987 *ofs_p
+= add_merge_info(fmt
, dst
, commit
, abbrev
);
992 * MEDIUM == DEFAULT shows only author with dates.
993 * FULL shows both authors but not dates.
994 * FULLER shows both authors and dates.
996 if (!memcmp(line
, "author ", 7)) {
998 if (fmt
== CMIT_FMT_EMAIL
)
999 len
= bound_rfc2047(linelen
, encoding
);
1000 ALLOC_GROW(*buf_p
, *ofs_p
+ len
, *space_p
);
1001 dst
= *buf_p
+ *ofs_p
;
1002 *ofs_p
+= add_user_info("Author", fmt
, dst
,
1003 line
+ 7, dmode
, encoding
);
1006 if (!memcmp(line
, "committer ", 10) &&
1007 (fmt
== CMIT_FMT_FULL
|| fmt
== CMIT_FMT_FULLER
)) {
1009 if (fmt
== CMIT_FMT_EMAIL
)
1010 len
= bound_rfc2047(linelen
, encoding
);
1011 ALLOC_GROW(*buf_p
, *ofs_p
+ len
, *space_p
);
1012 dst
= *buf_p
+ *ofs_p
;
1013 *ofs_p
+= add_user_info("Commit", fmt
, dst
,
1014 line
+ 10, dmode
, encoding
);
1019 static void pp_title_line(enum cmit_fmt fmt
,
1021 unsigned long *len_p
,
1022 unsigned long *ofs_p
,
1024 unsigned long *space_p
,
1026 const char *subject
,
1027 const char *after_subject
,
1028 const char *encoding
,
1029 int plain_non_ascii
)
1032 unsigned long title_alloc
, title_len
;
1037 title
= xmalloc(title_alloc
);
1039 const char *line
= *msg_p
;
1040 int linelen
= get_one_line(line
, *len_p
);
1044 if (!linelen
|| is_empty_line(line
, &linelen
))
1047 if (title_alloc
<= title_len
+ linelen
+ 2) {
1048 title_alloc
= title_len
+ linelen
+ 80;
1049 title
= xrealloc(title
, title_alloc
);
1053 if (fmt
== CMIT_FMT_EMAIL
) {
1055 title
[title_len
++] = '\n';
1058 title
[title_len
++] = ' ';
1060 memcpy(title
+ title_len
, line
, linelen
);
1061 title_len
+= linelen
;
1064 /* Enough slop for the MIME header and rfc2047 */
1065 len
= bound_rfc2047(title_len
, encoding
)+ 1000;
1067 len
+= strlen(subject
);
1069 len
+= strlen(after_subject
);
1071 len
+= strlen(encoding
);
1072 ALLOC_GROW(*buf_p
, title_len
+ *ofs_p
+ len
, *space_p
);
1075 len
= strlen(subject
);
1076 memcpy(*buf_p
+ *ofs_p
, subject
, len
);
1078 *ofs_p
+= add_rfc2047(*buf_p
+ *ofs_p
,
1079 title
, title_len
, encoding
);
1081 memcpy(*buf_p
+ *ofs_p
, title
, title_len
);
1082 *ofs_p
+= title_len
;
1084 (*buf_p
)[(*ofs_p
)++] = '\n';
1085 if (plain_non_ascii
) {
1086 const char *header_fmt
=
1087 "MIME-Version: 1.0\n"
1088 "Content-Type: text/plain; charset=%s\n"
1089 "Content-Transfer-Encoding: 8bit\n";
1090 *ofs_p
+= snprintf(*buf_p
+ *ofs_p
,
1092 header_fmt
, encoding
);
1094 if (after_subject
) {
1095 len
= strlen(after_subject
);
1096 memcpy(*buf_p
+ *ofs_p
, after_subject
, len
);
1100 if (fmt
== CMIT_FMT_EMAIL
) {
1101 ALLOC_GROW(*buf_p
, *ofs_p
+ 20, *space_p
);
1102 (*buf_p
)[(*ofs_p
)++] = '\n';
1106 static void pp_remainder(enum cmit_fmt fmt
,
1108 unsigned long *len_p
,
1109 unsigned long *ofs_p
,
1111 unsigned long *space_p
,
1116 const char *line
= *msg_p
;
1117 int linelen
= get_one_line(line
, *len_p
);
1124 if (is_empty_line(line
, &linelen
)) {
1127 if (fmt
== CMIT_FMT_SHORT
)
1132 ALLOC_GROW(*buf_p
, *ofs_p
+ linelen
+ indent
+ 20, *space_p
);
1134 memset(*buf_p
+ *ofs_p
, ' ', indent
);
1137 memcpy(*buf_p
+ *ofs_p
, line
, linelen
);
1139 (*buf_p
)[(*ofs_p
)++] = '\n';
1143 unsigned long pretty_print_commit(enum cmit_fmt fmt
,
1144 const struct commit
*commit
,
1146 char **buf_p
, unsigned long *space_p
,
1147 int abbrev
, const char *subject
,
1148 const char *after_subject
,
1149 enum date_mode dmode
)
1151 unsigned long offset
= 0;
1152 unsigned long beginning_of_body
;
1154 const char *msg
= commit
->buffer
;
1155 int plain_non_ascii
= 0;
1157 const char *encoding
;
1160 if (fmt
== CMIT_FMT_USERFORMAT
)
1161 return format_commit_message(commit
, msg
, buf_p
, space_p
);
1163 encoding
= (git_log_output_encoding
1164 ? git_log_output_encoding
1165 : git_commit_encoding
);
1168 reencoded
= logmsg_reencode(commit
, encoding
);
1171 len
= strlen(reencoded
);
1174 if (fmt
== CMIT_FMT_ONELINE
|| fmt
== CMIT_FMT_EMAIL
)
1177 /* After-subject is used to pass in Content-Type: multipart
1178 * MIME header; in that case we do not have to do the
1179 * plaintext content type even if the commit message has
1180 * non 7-bit ASCII character. Otherwise, check if we need
1181 * to say this is not a 7-bit ASCII.
1183 if (fmt
== CMIT_FMT_EMAIL
&& !after_subject
) {
1186 for (in_body
= i
= 0; (ch
= msg
[i
]) && i
< len
; i
++) {
1188 /* author could be non 7-bit ASCII but
1189 * the log may be so; skip over the
1190 * header part first.
1193 i
+ 1 < len
&& msg
[i
+1] == '\n')
1196 else if (non_ascii(ch
)) {
1197 plain_non_ascii
= 1;
1203 pp_header(fmt
, abbrev
, dmode
, encoding
,
1205 &offset
, buf_p
, space_p
);
1206 if (fmt
!= CMIT_FMT_ONELINE
&& !subject
) {
1207 ALLOC_GROW(*buf_p
, offset
+ 20, *space_p
);
1208 (*buf_p
)[offset
++] = '\n';
1211 /* Skip excess blank lines at the beginning of body, if any... */
1213 int linelen
= get_one_line(msg
, len
);
1217 if (!is_empty_line(msg
, &ll
))
1223 /* These formats treat the title line specially. */
1224 if (fmt
== CMIT_FMT_ONELINE
1225 || fmt
== CMIT_FMT_EMAIL
)
1226 pp_title_line(fmt
, &msg
, &len
, &offset
,
1227 buf_p
, space_p
, indent
,
1228 subject
, after_subject
, encoding
,
1231 beginning_of_body
= offset
;
1232 if (fmt
!= CMIT_FMT_ONELINE
)
1233 pp_remainder(fmt
, &msg
, &len
, &offset
,
1234 buf_p
, space_p
, indent
);
1236 while (offset
&& isspace((*buf_p
)[offset
-1]))
1239 ALLOC_GROW(*buf_p
, offset
+ 20, *space_p
);
1242 /* Make sure there is an EOLN for the non-oneline case */
1243 if (fmt
!= CMIT_FMT_ONELINE
)
1244 buf
[offset
++] = '\n';
1247 * The caller may append additional body text in e-mail
1248 * format. Make sure we did not strip the blank line
1249 * between the header and the body.
1251 if (fmt
== CMIT_FMT_EMAIL
&& offset
<= beginning_of_body
)
1252 buf
[offset
++] = '\n';
1258 struct commit
*pop_commit(struct commit_list
**stack
)
1260 struct commit_list
*top
= *stack
;
1261 struct commit
*item
= top
? top
->item
: NULL
;
1270 void topo_sort_default_setter(struct commit
*c
, void *data
)
1275 void *topo_sort_default_getter(struct commit
*c
)
1281 * Performs an in-place topological sort on the list supplied.
1283 void sort_in_topological_order(struct commit_list
** list
, int lifo
)
1285 sort_in_topological_order_fn(list
, lifo
, topo_sort_default_setter
,
1286 topo_sort_default_getter
);
1289 void sort_in_topological_order_fn(struct commit_list
** list
, int lifo
,
1290 topo_sort_set_fn_t setter
,
1291 topo_sort_get_fn_t getter
)
1293 struct commit_list
* next
= *list
;
1294 struct commit_list
* work
= NULL
, **insert
;
1295 struct commit_list
** pptr
= list
;
1296 struct sort_node
* nodes
;
1297 struct sort_node
* next_nodes
;
1300 /* determine the size of the list */
1308 /* allocate an array to help sort the list */
1309 nodes
= xcalloc(count
, sizeof(*nodes
));
1310 /* link the list to the array */
1314 next_nodes
->list_item
= next
;
1315 setter(next
->item
, next_nodes
);
1319 /* update the indegree */
1322 struct commit_list
* parents
= next
->item
->parents
;
1324 struct commit
* parent
=parents
->item
;
1325 struct sort_node
* pn
= (struct sort_node
*) getter(parent
);
1329 parents
=parents
->next
;
1336 * tips are nodes not reachable from any other node in the list
1338 * the tips serve as a starting set for the work queue.
1343 struct sort_node
* node
= (struct sort_node
*) getter(next
->item
);
1345 if (node
->indegree
== 0) {
1346 insert
= &commit_list_insert(next
->item
, insert
)->next
;
1351 /* process the list in topological order */
1353 sort_by_date(&work
);
1355 struct commit
* work_item
= pop_commit(&work
);
1356 struct sort_node
* work_node
= (struct sort_node
*) getter(work_item
);
1357 struct commit_list
* parents
= work_item
->parents
;
1360 struct commit
* parent
=parents
->item
;
1361 struct sort_node
* pn
= (struct sort_node
*) getter(parent
);
1365 * parents are only enqueued for emission
1366 * when all their children have been emitted thereby
1367 * guaranteeing topological order.
1370 if (!pn
->indegree
) {
1372 insert_by_date(parent
, &work
);
1374 commit_list_insert(parent
, &work
);
1377 parents
=parents
->next
;
1380 * work_item is a commit all of whose children
1381 * have already been emitted. we can emit it now.
1383 *pptr
= work_node
->list_item
;
1384 pptr
= &(*pptr
)->next
;
1386 setter(work_item
, NULL
);
1391 /* merge-base stuff */
1393 /* bits #0..15 in revision.h */
1394 #define PARENT1 (1u<<16)
1395 #define PARENT2 (1u<<17)
1396 #define STALE (1u<<18)
1397 #define RESULT (1u<<19)
1399 static const unsigned all_flags
= (PARENT1
| PARENT2
| STALE
| RESULT
);
1401 static struct commit
*interesting(struct commit_list
*list
)
1404 struct commit
*commit
= list
->item
;
1406 if (commit
->object
.flags
& STALE
)
1413 static struct commit_list
*merge_bases(struct commit
*one
, struct commit
*two
)
1415 struct commit_list
*list
= NULL
;
1416 struct commit_list
*result
= NULL
;
1419 /* We do not mark this even with RESULT so we do not
1420 * have to clean it up.
1422 return commit_list_insert(one
, &result
);
1427 one
->object
.flags
|= PARENT1
;
1428 two
->object
.flags
|= PARENT2
;
1429 insert_by_date(one
, &list
);
1430 insert_by_date(two
, &list
);
1432 while (interesting(list
)) {
1433 struct commit
*commit
;
1434 struct commit_list
*parents
;
1435 struct commit_list
*n
;
1438 commit
= list
->item
;
1443 flags
= commit
->object
.flags
& (PARENT1
| PARENT2
| STALE
);
1444 if (flags
== (PARENT1
| PARENT2
)) {
1445 if (!(commit
->object
.flags
& RESULT
)) {
1446 commit
->object
.flags
|= RESULT
;
1447 insert_by_date(commit
, &result
);
1449 /* Mark parents of a found merge stale */
1452 parents
= commit
->parents
;
1454 struct commit
*p
= parents
->item
;
1455 parents
= parents
->next
;
1456 if ((p
->object
.flags
& flags
) == flags
)
1459 p
->object
.flags
|= flags
;
1460 insert_by_date(p
, &list
);
1464 /* Clean up the result to remove stale ones */
1465 free_commit_list(list
);
1466 list
= result
; result
= NULL
;
1468 struct commit_list
*n
= list
->next
;
1469 if (!(list
->item
->object
.flags
& STALE
))
1470 insert_by_date(list
->item
, &result
);
1477 struct commit_list
*get_merge_bases(struct commit
*one
,
1481 struct commit_list
*list
;
1482 struct commit
**rslt
;
1483 struct commit_list
*result
;
1486 result
= merge_bases(one
, two
);
1489 if (!result
|| !result
->next
) {
1491 clear_commit_marks(one
, all_flags
);
1492 clear_commit_marks(two
, all_flags
);
1497 /* There are more than one */
1504 rslt
= xcalloc(cnt
, sizeof(*rslt
));
1505 for (list
= result
, i
= 0; list
; list
= list
->next
)
1506 rslt
[i
++] = list
->item
;
1507 free_commit_list(result
);
1509 clear_commit_marks(one
, all_flags
);
1510 clear_commit_marks(two
, all_flags
);
1511 for (i
= 0; i
< cnt
- 1; i
++) {
1512 for (j
= i
+1; j
< cnt
; j
++) {
1513 if (!rslt
[i
] || !rslt
[j
])
1515 result
= merge_bases(rslt
[i
], rslt
[j
]);
1516 clear_commit_marks(rslt
[i
], all_flags
);
1517 clear_commit_marks(rslt
[j
], all_flags
);
1518 for (list
= result
; list
; list
= list
->next
) {
1519 if (rslt
[i
] == list
->item
)
1521 if (rslt
[j
] == list
->item
)
1527 /* Surviving ones in rslt[] are the independent results */
1529 for (i
= 0; i
< cnt
; i
++) {
1531 insert_by_date(rslt
[i
], &result
);
1537 int in_merge_bases(struct commit
*commit
, struct commit
**reference
, int num
)
1539 struct commit_list
*bases
, *b
;
1543 bases
= get_merge_bases(commit
, *reference
, 1);
1546 for (b
= bases
; b
; b
= b
->next
) {
1547 if (!hashcmp(commit
->object
.sha1
, b
->item
->object
.sha1
)) {
1553 free_commit_list(bases
);