6 #include "string-list.h"
11 #include "reflog-walk.h"
12 #include "gpg-interface.h"
14 static char *user_format
;
15 static struct cmt_fmt_map
{
20 const char *user_format
;
22 static size_t builtin_formats_len
;
23 static size_t commit_formats_len
;
24 static size_t commit_formats_alloc
;
25 static struct cmt_fmt_map
*find_commit_format(const char *sought
);
27 int commit_format_is_empty(enum cmit_fmt fmt
)
29 return fmt
== CMIT_FMT_USERFORMAT
&& !*user_format
;
32 static void save_user_format(struct rev_info
*rev
, const char *cp
, int is_tformat
)
35 user_format
= xstrdup(cp
);
37 rev
->use_terminator
= 1;
38 rev
->commit_format
= CMIT_FMT_USERFORMAT
;
41 static int git_pretty_formats_config(const char *var
, const char *value
, void *cb
)
43 struct cmt_fmt_map
*commit_format
= NULL
;
48 if (!skip_prefix(var
, "pretty.", &name
))
51 for (i
= 0; i
< builtin_formats_len
; i
++) {
52 if (!strcmp(commit_formats
[i
].name
, name
))
56 for (i
= builtin_formats_len
; i
< commit_formats_len
; i
++) {
57 if (!strcmp(commit_formats
[i
].name
, name
)) {
58 commit_format
= &commit_formats
[i
];
64 ALLOC_GROW(commit_formats
, commit_formats_len
+1,
65 commit_formats_alloc
);
66 commit_format
= &commit_formats
[commit_formats_len
];
67 memset(commit_format
, 0, sizeof(*commit_format
));
71 commit_format
->name
= xstrdup(name
);
72 commit_format
->format
= CMIT_FMT_USERFORMAT
;
73 if (git_config_string(&fmt
, var
, value
))
76 if (starts_with(fmt
, "format:") || starts_with(fmt
, "tformat:")) {
77 commit_format
->is_tformat
= fmt
[0] == 't';
78 fmt
= strchr(fmt
, ':') + 1;
79 } else if (strchr(fmt
, '%'))
80 commit_format
->is_tformat
= 1;
82 commit_format
->is_alias
= 1;
83 commit_format
->user_format
= fmt
;
88 static void setup_commit_formats(void)
90 struct cmt_fmt_map builtin_formats
[] = {
91 { "raw", CMIT_FMT_RAW
, 0 },
92 { "medium", CMIT_FMT_MEDIUM
, 0 },
93 { "short", CMIT_FMT_SHORT
, 0 },
94 { "email", CMIT_FMT_EMAIL
, 0 },
95 { "fuller", CMIT_FMT_FULLER
, 0 },
96 { "full", CMIT_FMT_FULL
, 0 },
97 { "oneline", CMIT_FMT_ONELINE
, 1 }
99 commit_formats_len
= ARRAY_SIZE(builtin_formats
);
100 builtin_formats_len
= commit_formats_len
;
101 ALLOC_GROW(commit_formats
, commit_formats_len
, commit_formats_alloc
);
102 memcpy(commit_formats
, builtin_formats
,
103 sizeof(*builtin_formats
)*ARRAY_SIZE(builtin_formats
));
105 git_config(git_pretty_formats_config
, NULL
);
108 static struct cmt_fmt_map
*find_commit_format_recursive(const char *sought
,
109 const char *original
,
110 int num_redirections
)
112 struct cmt_fmt_map
*found
= NULL
;
113 size_t found_match_len
= 0;
116 if (num_redirections
>= commit_formats_len
)
117 die("invalid --pretty format: "
118 "'%s' references an alias which points to itself",
121 for (i
= 0; i
< commit_formats_len
; i
++) {
124 if (!starts_with(commit_formats
[i
].name
, sought
))
127 match_len
= strlen(commit_formats
[i
].name
);
128 if (found
== NULL
|| found_match_len
> match_len
) {
129 found
= &commit_formats
[i
];
130 found_match_len
= match_len
;
134 if (found
&& found
->is_alias
) {
135 found
= find_commit_format_recursive(found
->user_format
,
143 static struct cmt_fmt_map
*find_commit_format(const char *sought
)
146 setup_commit_formats();
148 return find_commit_format_recursive(sought
, sought
, 0);
151 void get_commit_format(const char *arg
, struct rev_info
*rev
)
153 struct cmt_fmt_map
*commit_format
;
155 rev
->use_terminator
= 0;
157 rev
->commit_format
= CMIT_FMT_DEFAULT
;
160 if (starts_with(arg
, "format:") || starts_with(arg
, "tformat:")) {
161 save_user_format(rev
, strchr(arg
, ':') + 1, arg
[0] == 't');
165 if (!*arg
|| strchr(arg
, '%')) {
166 save_user_format(rev
, arg
, 1);
170 commit_format
= find_commit_format(arg
);
172 die("invalid --pretty format: %s", arg
);
174 rev
->commit_format
= commit_format
->format
;
175 rev
->use_terminator
= commit_format
->is_tformat
;
176 if (commit_format
->format
== CMIT_FMT_USERFORMAT
) {
177 save_user_format(rev
, commit_format
->user_format
,
178 commit_format
->is_tformat
);
183 * Generic support for pretty-printing the header
185 static int get_one_line(const char *msg
)
200 /* High bit set, or ISO-2022-INT */
201 static int non_ascii(int ch
)
203 return !isascii(ch
) || ch
== '\033';
206 int has_non_ascii(const char *s
)
211 while ((ch
= *s
++) != '\0') {
218 static int is_rfc822_special(char ch
)
240 static int needs_rfc822_quoting(const char *s
, int len
)
243 for (i
= 0; i
< len
; i
++)
244 if (is_rfc822_special(s
[i
]))
249 static int last_line_length(struct strbuf
*sb
)
253 /* How many bytes are already used on the last line? */
254 for (i
= sb
->len
- 1; i
>= 0; i
--)
255 if (sb
->buf
[i
] == '\n')
257 return sb
->len
- (i
+ 1);
260 static void add_rfc822_quoted(struct strbuf
*out
, const char *s
, int len
)
264 /* just a guess, we may have to also backslash-quote */
265 strbuf_grow(out
, len
+ 2);
267 strbuf_addch(out
, '"');
268 for (i
= 0; i
< len
; i
++) {
272 strbuf_addch(out
, '\\');
275 strbuf_addch(out
, s
[i
]);
278 strbuf_addch(out
, '"');
286 static int is_rfc2047_special(char ch
, enum rfc2047_type type
)
289 * rfc2047, section 4.2:
291 * 8-bit values which correspond to printable ASCII characters other
292 * than "=", "?", and "_" (underscore), MAY be represented as those
293 * characters. (But see section 5 for restrictions.) In
294 * particular, SPACE and TAB MUST NOT be represented as themselves
295 * within encoded words.
299 * rule out non-ASCII characters and non-printable characters (the
300 * non-ASCII check should be redundant as isprint() is not localized
301 * and only knows about ASCII, but be defensive about that)
303 if (non_ascii(ch
) || !isprint(ch
))
307 * rule out special printable characters (' ' should be the only
308 * whitespace character considered printable, but be defensive and use
311 if (isspace(ch
) || ch
== '=' || ch
== '?' || ch
== '_')
315 * rfc2047, section 5.3:
317 * As a replacement for a 'word' entity within a 'phrase', for example,
318 * one that precedes an address in a From, To, or Cc header. The ABNF
319 * definition for 'phrase' from RFC 822 thus becomes:
321 * phrase = 1*( encoded-word / word )
323 * In this case the set of characters that may be used in a "Q"-encoded
324 * 'encoded-word' is restricted to: <upper and lower case ASCII
325 * letters, decimal digits, "!", "*", "+", "-", "/", "=", and "_"
326 * (underscore, ASCII 95.)>. An 'encoded-word' that appears within a
327 * 'phrase' MUST be separated from any adjacent 'word', 'text' or
328 * 'special' by 'linear-white-space'.
331 if (type
!= RFC2047_ADDRESS
)
334 /* '=' and '_' are special cases and have been checked above */
335 return !(isalnum(ch
) || ch
== '!' || ch
== '*' || ch
== '+' || ch
== '-' || ch
== '/');
338 static int needs_rfc2047_encoding(const char *line
, int len
,
339 enum rfc2047_type type
)
343 for (i
= 0; i
< len
; i
++) {
345 if (non_ascii(ch
) || ch
== '\n')
347 if ((i
+ 1 < len
) && (ch
== '=' && line
[i
+1] == '?'))
354 static void add_rfc2047(struct strbuf
*sb
, const char *line
, size_t len
,
355 const char *encoding
, enum rfc2047_type type
)
357 static const int max_encoded_length
= 76; /* per rfc2047 */
359 int line_len
= last_line_length(sb
);
361 strbuf_grow(sb
, len
* 3 + strlen(encoding
) + 100);
362 strbuf_addf(sb
, "=?%s?q?", encoding
);
363 line_len
+= strlen(encoding
) + 5; /* 5 for =??q? */
367 * RFC 2047, section 5 (3):
369 * Each 'encoded-word' MUST represent an integral number of
370 * characters. A multi-octet character may not be split across
371 * adjacent 'encoded- word's.
373 const unsigned char *p
= (const unsigned char *)line
;
374 int chrlen
= mbs_chrlen(&line
, &len
, encoding
);
375 int is_special
= (chrlen
> 1) || is_rfc2047_special(*p
, type
);
377 /* "=%02X" * chrlen, or the byte itself */
378 const char *encoded_fmt
= is_special
? "=%02X" : "%c";
379 int encoded_len
= is_special
? 3 * chrlen
: 1;
382 * According to RFC 2047, we could encode the special character
383 * ' ' (space) with '_' (underscore) for readability. But many
384 * programs do not understand this and just leave the
385 * underscore in place. Thus, we do nothing special here, which
386 * causes ' ' to be encoded as '=20', avoiding this problem.
389 if (line_len
+ encoded_len
+ 2 > max_encoded_length
) {
390 /* It won't fit with trailing "?=" --- break the line */
391 strbuf_addf(sb
, "?=\n =?%s?q?", encoding
);
392 line_len
= strlen(encoding
) + 5 + 1; /* =??q? plus SP */
395 for (i
= 0; i
< chrlen
; i
++)
396 strbuf_addf(sb
, encoded_fmt
, p
[i
]);
397 line_len
+= encoded_len
;
399 strbuf_addstr(sb
, "?=");
402 const char *show_ident_date(const struct ident_split
*ident
,
405 unsigned long date
= 0;
408 if (ident
->date_begin
&& ident
->date_end
)
409 date
= strtoul(ident
->date_begin
, NULL
, 10);
410 if (date_overflows(date
))
413 if (ident
->tz_begin
&& ident
->tz_end
)
414 tz
= strtol(ident
->tz_begin
, NULL
, 10);
415 if (tz
>= INT_MAX
|| tz
<= INT_MIN
)
418 return show_date(date
, tz
, mode
);
421 void pp_user_info(struct pretty_print_context
*pp
,
422 const char *what
, struct strbuf
*sb
,
423 const char *line
, const char *encoding
)
425 struct ident_split ident
;
427 const char *mailbuf
, *namebuf
;
428 size_t namelen
, maillen
;
429 int max_length
= 78; /* per rfc2822 */
431 if (pp
->fmt
== CMIT_FMT_ONELINE
)
434 line_end
= strchrnul(line
, '\n');
435 if (split_ident_line(&ident
, line
, line_end
- line
))
438 mailbuf
= ident
.mail_begin
;
439 maillen
= ident
.mail_end
- ident
.mail_begin
;
440 namebuf
= ident
.name_begin
;
441 namelen
= ident
.name_end
- ident
.name_begin
;
444 map_user(pp
->mailmap
, &mailbuf
, &maillen
, &namebuf
, &namelen
);
446 if (pp
->fmt
== CMIT_FMT_EMAIL
) {
447 if (pp
->from_ident
&& ident_cmp(pp
->from_ident
, &ident
)) {
448 struct strbuf buf
= STRBUF_INIT
;
450 strbuf_addstr(&buf
, "From: ");
451 strbuf_add(&buf
, namebuf
, namelen
);
452 strbuf_addstr(&buf
, " <");
453 strbuf_add(&buf
, mailbuf
, maillen
);
454 strbuf_addstr(&buf
, ">\n");
455 string_list_append(&pp
->in_body_headers
,
456 strbuf_detach(&buf
, NULL
));
458 mailbuf
= pp
->from_ident
->mail_begin
;
459 maillen
= pp
->from_ident
->mail_end
- mailbuf
;
460 namebuf
= pp
->from_ident
->name_begin
;
461 namelen
= pp
->from_ident
->name_end
- namebuf
;
464 strbuf_addstr(sb
, "From: ");
465 if (needs_rfc2047_encoding(namebuf
, namelen
, RFC2047_ADDRESS
)) {
466 add_rfc2047(sb
, namebuf
, namelen
,
467 encoding
, RFC2047_ADDRESS
);
468 max_length
= 76; /* per rfc2047 */
469 } else if (needs_rfc822_quoting(namebuf
, namelen
)) {
470 struct strbuf quoted
= STRBUF_INIT
;
471 add_rfc822_quoted("ed
, namebuf
, namelen
);
472 strbuf_add_wrapped_bytes(sb
, quoted
.buf
, quoted
.len
,
474 strbuf_release("ed
);
476 strbuf_add_wrapped_bytes(sb
, namebuf
, namelen
,
481 last_line_length(sb
) + strlen(" <") + maillen
+ strlen(">"))
482 strbuf_addch(sb
, '\n');
483 strbuf_addf(sb
, " <%.*s>\n", (int)maillen
, mailbuf
);
485 strbuf_addf(sb
, "%s: %.*s%.*s <%.*s>\n", what
,
486 (pp
->fmt
== CMIT_FMT_FULLER
) ? 4 : 0, " ",
487 (int)namelen
, namebuf
, (int)maillen
, mailbuf
);
491 case CMIT_FMT_MEDIUM
:
492 strbuf_addf(sb
, "Date: %s\n",
493 show_ident_date(&ident
, pp
->date_mode
));
496 strbuf_addf(sb
, "Date: %s\n",
497 show_ident_date(&ident
, DATE_RFC2822
));
499 case CMIT_FMT_FULLER
:
500 strbuf_addf(sb
, "%sDate: %s\n", what
,
501 show_ident_date(&ident
, pp
->date_mode
));
509 static int is_empty_line(const char *line
, int *len_p
)
512 while (len
&& isspace(line
[len
- 1]))
518 static const char *skip_empty_lines(const char *msg
)
521 int linelen
= get_one_line(msg
);
525 if (!is_empty_line(msg
, &ll
))
532 static void add_merge_info(const struct pretty_print_context
*pp
,
533 struct strbuf
*sb
, const struct commit
*commit
)
535 struct commit_list
*parent
= commit
->parents
;
537 if ((pp
->fmt
== CMIT_FMT_ONELINE
) || (pp
->fmt
== CMIT_FMT_EMAIL
) ||
538 !parent
|| !parent
->next
)
541 strbuf_addstr(sb
, "Merge:");
544 struct commit
*p
= parent
->item
;
545 const char *hex
= NULL
;
547 hex
= find_unique_abbrev(p
->object
.sha1
, pp
->abbrev
);
549 hex
= sha1_to_hex(p
->object
.sha1
);
550 parent
= parent
->next
;
552 strbuf_addf(sb
, " %s", hex
);
554 strbuf_addch(sb
, '\n');
557 static char *get_header(const struct commit
*commit
, const char *msg
,
560 int key_len
= strlen(key
);
561 const char *line
= msg
;
564 const char *eol
= strchrnul(line
, '\n'), *next
;
569 warning("malformed commit (header is missing newline): %s",
570 sha1_to_hex(commit
->object
.sha1
));
574 if (eol
- line
> key_len
&&
575 !strncmp(line
, key
, key_len
) &&
576 line
[key_len
] == ' ') {
577 return xmemdupz(line
+ key_len
+ 1, eol
- line
- key_len
- 1);
584 static char *replace_encoding_header(char *buf
, const char *encoding
)
586 struct strbuf tmp
= STRBUF_INIT
;
590 /* guess if there is an encoding header before a \n\n */
591 while (strncmp(cp
, "encoding ", strlen("encoding "))) {
592 cp
= strchr(cp
, '\n');
593 if (!cp
|| *++cp
== '\n')
597 cp
= strchr(cp
, '\n');
599 return buf
; /* should not happen but be defensive */
600 len
= cp
+ 1 - (buf
+ start
);
602 strbuf_attach(&tmp
, buf
, strlen(buf
), strlen(buf
) + 1);
603 if (is_encoding_utf8(encoding
)) {
604 /* we have re-coded to UTF-8; drop the header */
605 strbuf_remove(&tmp
, start
, len
);
607 /* just replaces XXXX in 'encoding XXXX\n' */
608 strbuf_splice(&tmp
, start
+ strlen("encoding "),
609 len
- strlen("encoding \n"),
610 encoding
, strlen(encoding
));
612 return strbuf_detach(&tmp
, NULL
);
615 const char *logmsg_reencode(const struct commit
*commit
,
616 char **commit_encoding
,
617 const char *output_encoding
)
619 static const char *utf8
= "UTF-8";
620 const char *use_encoding
;
622 const char *msg
= get_commit_buffer(commit
, NULL
);
625 if (!output_encoding
|| !*output_encoding
) {
628 get_header(commit
, msg
, "encoding");
631 encoding
= get_header(commit
, msg
, "encoding");
633 *commit_encoding
= encoding
;
634 use_encoding
= encoding
? encoding
: utf8
;
635 if (same_encoding(use_encoding
, output_encoding
)) {
637 * No encoding work to be done. If we have no encoding header
638 * at all, then there's nothing to do, and we can return the
639 * message verbatim (whether newly allocated or not).
645 * Otherwise, we still want to munge the encoding header in the
646 * result, which will be done by modifying the buffer. If we
647 * are using a fresh copy, we can reuse it. But if we are using
648 * the cached copy from get_commit_buffer, we need to duplicate it
649 * to avoid munging the cached copy.
651 if (msg
== get_cached_commit_buffer(commit
, NULL
))
658 * There's actual encoding work to do. Do the reencoding, which
659 * still leaves the header to be replaced in the next step. At
660 * this point, we are done with msg. If we allocated a fresh
661 * copy, we can free it.
663 out
= reencode_string(msg
, output_encoding
, use_encoding
);
665 unuse_commit_buffer(commit
, msg
);
669 * This replacement actually consumes the buffer we hand it, so we do
670 * not have to worry about freeing the old "out" here.
673 out
= replace_encoding_header(out
, output_encoding
);
675 if (!commit_encoding
)
678 * If the re-encoding failed, out might be NULL here; in that
679 * case we just return the commit message verbatim.
681 return out
? out
: msg
;
684 static int mailmap_name(const char **email
, size_t *email_len
,
685 const char **name
, size_t *name_len
)
687 static struct string_list
*mail_map
;
689 mail_map
= xcalloc(1, sizeof(*mail_map
));
690 read_mailmap(mail_map
, NULL
);
692 return mail_map
->nr
&& map_user(mail_map
, email
, email_len
, name
, name_len
);
695 static size_t format_person_part(struct strbuf
*sb
, char part
,
696 const char *msg
, int len
, enum date_mode dmode
)
698 /* currently all placeholders have same length */
699 const int placeholder_len
= 2;
700 struct ident_split s
;
701 const char *name
, *mail
;
702 size_t maillen
, namelen
;
704 if (split_ident_line(&s
, msg
, len
) < 0)
708 namelen
= s
.name_end
- s
.name_begin
;
710 maillen
= s
.mail_end
- s
.mail_begin
;
712 if (part
== 'N' || part
== 'E') /* mailmap lookup */
713 mailmap_name(&mail
, &maillen
, &name
, &namelen
);
714 if (part
== 'n' || part
== 'N') { /* name */
715 strbuf_add(sb
, name
, namelen
);
716 return placeholder_len
;
718 if (part
== 'e' || part
== 'E') { /* email */
719 strbuf_add(sb
, mail
, maillen
);
720 return placeholder_len
;
726 if (part
== 't') { /* date, UNIX timestamp */
727 strbuf_add(sb
, s
.date_begin
, s
.date_end
- s
.date_begin
);
728 return placeholder_len
;
733 strbuf_addstr(sb
, show_ident_date(&s
, dmode
));
734 return placeholder_len
;
735 case 'D': /* date, RFC2822 style */
736 strbuf_addstr(sb
, show_ident_date(&s
, DATE_RFC2822
));
737 return placeholder_len
;
738 case 'r': /* date, relative */
739 strbuf_addstr(sb
, show_ident_date(&s
, DATE_RELATIVE
));
740 return placeholder_len
;
741 case 'i': /* date, ISO 8601-like */
742 strbuf_addstr(sb
, show_ident_date(&s
, DATE_ISO8601
));
743 return placeholder_len
;
744 case 'I': /* date, ISO 8601 strict */
745 strbuf_addstr(sb
, show_ident_date(&s
, DATE_ISO8601_STRICT
));
746 return placeholder_len
;
751 * reading from either a bogus commit, or a reflog entry with
752 * %gn, %ge, etc.; 'sb' cannot be updated, but we still need
753 * to compute a valid return value.
755 if (part
== 'n' || part
== 'e' || part
== 't' || part
== 'd'
756 || part
== 'D' || part
== 'r' || part
== 'i')
757 return placeholder_len
;
759 return 0; /* unknown placeholder */
771 flush_left_and_steal
,
782 struct format_commit_context
{
783 const struct commit
*commit
;
784 const struct pretty_print_context
*pretty_ctx
;
785 unsigned commit_header_parsed
:1;
786 unsigned commit_message_parsed
:1;
787 struct signature_check signature_check
;
788 enum flush_type flush_type
;
789 enum trunc_type truncate
;
791 char *commit_encoding
;
792 size_t width
, indent1
, indent2
;
796 /* These offsets are relative to the start of the commit message. */
798 struct chunk committer
;
803 /* The following ones are relative to the result struct strbuf. */
804 struct chunk abbrev_commit_hash
;
805 struct chunk abbrev_tree_hash
;
806 struct chunk abbrev_parent_hashes
;
810 static int add_again(struct strbuf
*sb
, struct chunk
*chunk
)
813 strbuf_adddup(sb
, chunk
->off
, chunk
->len
);
818 * We haven't seen this chunk before. Our caller is surely
819 * going to add it the hard way now. Remember the most likely
820 * start of the to-be-added chunk: the current end of the
823 chunk
->off
= sb
->len
;
827 static void parse_commit_header(struct format_commit_context
*context
)
829 const char *msg
= context
->message
;
832 for (i
= 0; msg
[i
]; i
++) {
834 for (eol
= i
; msg
[eol
] && msg
[eol
] != '\n'; eol
++)
839 } else if (starts_with(msg
+ i
, "author ")) {
840 context
->author
.off
= i
+ 7;
841 context
->author
.len
= eol
- i
- 7;
842 } else if (starts_with(msg
+ i
, "committer ")) {
843 context
->committer
.off
= i
+ 10;
844 context
->committer
.len
= eol
- i
- 10;
848 context
->message_off
= i
;
849 context
->commit_header_parsed
= 1;
852 static int istitlechar(char c
)
854 return (c
>= 'a' && c
<= 'z') || (c
>= 'A' && c
<= 'Z') ||
855 (c
>= '0' && c
<= '9') || c
== '.' || c
== '_';
858 static void format_sanitized_subject(struct strbuf
*sb
, const char *msg
)
861 size_t start_len
= sb
->len
;
864 for (; *msg
&& *msg
!= '\n'; msg
++) {
865 if (istitlechar(*msg
)) {
867 strbuf_addch(sb
, '-');
869 strbuf_addch(sb
, *msg
);
871 while (*(msg
+1) == '.')
877 /* trim any trailing '.' or '-' characters */
879 while (sb
->len
- trimlen
> start_len
&&
880 (sb
->buf
[sb
->len
- 1 - trimlen
] == '.'
881 || sb
->buf
[sb
->len
- 1 - trimlen
] == '-'))
883 strbuf_remove(sb
, sb
->len
- trimlen
, trimlen
);
886 const char *format_subject(struct strbuf
*sb
, const char *msg
,
887 const char *line_separator
)
892 const char *line
= msg
;
893 int linelen
= get_one_line(line
);
896 if (!linelen
|| is_empty_line(line
, &linelen
))
901 strbuf_grow(sb
, linelen
+ 2);
903 strbuf_addstr(sb
, line_separator
);
904 strbuf_add(sb
, line
, linelen
);
910 static void parse_commit_message(struct format_commit_context
*c
)
912 const char *msg
= c
->message
+ c
->message_off
;
913 const char *start
= c
->message
;
915 msg
= skip_empty_lines(msg
);
916 c
->subject_off
= msg
- start
;
918 msg
= format_subject(NULL
, msg
, NULL
);
919 msg
= skip_empty_lines(msg
);
920 c
->body_off
= msg
- start
;
922 c
->commit_message_parsed
= 1;
925 static void strbuf_wrap(struct strbuf
*sb
, size_t pos
,
926 size_t width
, size_t indent1
, size_t indent2
)
928 struct strbuf tmp
= STRBUF_INIT
;
931 strbuf_add(&tmp
, sb
->buf
, pos
);
932 strbuf_add_wrapped_text(&tmp
, sb
->buf
+ pos
,
933 (int) indent1
, (int) indent2
, (int) width
);
934 strbuf_swap(&tmp
, sb
);
935 strbuf_release(&tmp
);
938 static void rewrap_message_tail(struct strbuf
*sb
,
939 struct format_commit_context
*c
,
940 size_t new_width
, size_t new_indent1
,
943 if (c
->width
== new_width
&& c
->indent1
== new_indent1
&&
944 c
->indent2
== new_indent2
)
946 if (c
->wrap_start
< sb
->len
)
947 strbuf_wrap(sb
, c
->wrap_start
, c
->width
, c
->indent1
, c
->indent2
);
948 c
->wrap_start
= sb
->len
;
949 c
->width
= new_width
;
950 c
->indent1
= new_indent1
;
951 c
->indent2
= new_indent2
;
954 static int format_reflog_person(struct strbuf
*sb
,
956 struct reflog_walk_info
*log
,
957 enum date_mode dmode
)
964 ident
= get_reflog_ident(log
);
968 return format_person_part(sb
, part
, ident
, strlen(ident
), dmode
);
971 static size_t parse_color(struct strbuf
*sb
, /* in UTF-8 */
972 const char *placeholder
,
973 struct format_commit_context
*c
)
975 if (placeholder
[1] == '(') {
976 const char *begin
= placeholder
+ 2;
977 const char *end
= strchr(begin
, ')');
978 char color
[COLOR_MAXLEN
];
982 if (starts_with(begin
, "auto,")) {
983 if (!want_color(c
->pretty_ctx
->color
))
984 return end
- placeholder
+ 1;
987 color_parse_mem(begin
,
989 "--pretty format", color
);
990 strbuf_addstr(sb
, color
);
991 return end
- placeholder
+ 1;
993 if (starts_with(placeholder
+ 1, "red")) {
994 strbuf_addstr(sb
, GIT_COLOR_RED
);
996 } else if (starts_with(placeholder
+ 1, "green")) {
997 strbuf_addstr(sb
, GIT_COLOR_GREEN
);
999 } else if (starts_with(placeholder
+ 1, "blue")) {
1000 strbuf_addstr(sb
, GIT_COLOR_BLUE
);
1002 } else if (starts_with(placeholder
+ 1, "reset")) {
1003 strbuf_addstr(sb
, GIT_COLOR_RESET
);
1009 static size_t parse_padding_placeholder(struct strbuf
*sb
,
1010 const char *placeholder
,
1011 struct format_commit_context
*c
)
1013 const char *ch
= placeholder
;
1014 enum flush_type flush_type
;
1019 flush_type
= flush_right
;
1023 flush_type
= flush_both
;
1025 } else if (*ch
== '>') {
1026 flush_type
= flush_left_and_steal
;
1029 flush_type
= flush_left
;
1035 /* the next value means "wide enough to that column" */
1042 const char *start
= ch
+ 1;
1043 const char *end
= start
+ strcspn(start
, ",)");
1046 if (!end
|| end
== start
)
1048 width
= strtoul(start
, &next
, 10);
1049 if (next
== start
|| width
== 0)
1051 c
->padding
= to_column
? -width
: width
;
1052 c
->flush_type
= flush_type
;
1056 end
= strchr(start
, ')');
1057 if (!end
|| end
== start
)
1059 if (starts_with(start
, "trunc)"))
1060 c
->truncate
= trunc_right
;
1061 else if (starts_with(start
, "ltrunc)"))
1062 c
->truncate
= trunc_left
;
1063 else if (starts_with(start
, "mtrunc)"))
1064 c
->truncate
= trunc_middle
;
1068 c
->truncate
= trunc_none
;
1070 return end
- placeholder
+ 1;
1075 static size_t format_commit_one(struct strbuf
*sb
, /* in UTF-8 */
1076 const char *placeholder
,
1079 struct format_commit_context
*c
= context
;
1080 const struct commit
*commit
= c
->commit
;
1081 const char *msg
= c
->message
;
1082 struct commit_list
*p
;
1085 /* these are independent of the commit */
1086 switch (placeholder
[0]) {
1088 if (starts_with(placeholder
+ 1, "(auto)")) {
1090 return 7; /* consumed 7 bytes, "C(auto)" */
1092 int ret
= parse_color(sb
, placeholder
, c
);
1096 * Otherwise, we decided to treat %C<unknown>
1097 * as a literal string, and the previous
1098 * %C(auto) is still valid.
1102 case 'n': /* newline */
1103 strbuf_addch(sb
, '\n');
1106 /* %x00 == NUL, %x0a == LF, etc. */
1107 if (0 <= (h1
= hexval_table
[0xff & placeholder
[1]]) &&
1109 0 <= (h2
= hexval_table
[0xff & placeholder
[2]]) &&
1111 strbuf_addch(sb
, (h1
<<4)|h2
);
1116 if (placeholder
[1] == '(') {
1117 unsigned long width
= 0, indent1
= 0, indent2
= 0;
1119 const char *start
= placeholder
+ 2;
1120 const char *end
= strchr(start
, ')');
1124 width
= strtoul(start
, &next
, 10);
1126 indent1
= strtoul(next
+ 1, &next
, 10);
1128 indent2
= strtoul(next
+ 1,
1135 rewrap_message_tail(sb
, c
, width
, indent1
, indent2
);
1136 return end
- placeholder
+ 1;
1142 return parse_padding_placeholder(sb
, placeholder
, c
);
1145 /* these depend on the commit */
1146 if (!commit
->object
.parsed
)
1147 parse_object(commit
->object
.sha1
);
1149 switch (placeholder
[0]) {
1150 case 'H': /* commit hash */
1151 strbuf_addstr(sb
, diff_get_color(c
->auto_color
, DIFF_COMMIT
));
1152 strbuf_addstr(sb
, sha1_to_hex(commit
->object
.sha1
));
1153 strbuf_addstr(sb
, diff_get_color(c
->auto_color
, DIFF_RESET
));
1155 case 'h': /* abbreviated commit hash */
1156 strbuf_addstr(sb
, diff_get_color(c
->auto_color
, DIFF_COMMIT
));
1157 if (add_again(sb
, &c
->abbrev_commit_hash
)) {
1158 strbuf_addstr(sb
, diff_get_color(c
->auto_color
, DIFF_RESET
));
1161 strbuf_addstr(sb
, find_unique_abbrev(commit
->object
.sha1
,
1162 c
->pretty_ctx
->abbrev
));
1163 strbuf_addstr(sb
, diff_get_color(c
->auto_color
, DIFF_RESET
));
1164 c
->abbrev_commit_hash
.len
= sb
->len
- c
->abbrev_commit_hash
.off
;
1166 case 'T': /* tree hash */
1167 strbuf_addstr(sb
, sha1_to_hex(commit
->tree
->object
.sha1
));
1169 case 't': /* abbreviated tree hash */
1170 if (add_again(sb
, &c
->abbrev_tree_hash
))
1172 strbuf_addstr(sb
, find_unique_abbrev(commit
->tree
->object
.sha1
,
1173 c
->pretty_ctx
->abbrev
));
1174 c
->abbrev_tree_hash
.len
= sb
->len
- c
->abbrev_tree_hash
.off
;
1176 case 'P': /* parent hashes */
1177 for (p
= commit
->parents
; p
; p
= p
->next
) {
1178 if (p
!= commit
->parents
)
1179 strbuf_addch(sb
, ' ');
1180 strbuf_addstr(sb
, sha1_to_hex(p
->item
->object
.sha1
));
1183 case 'p': /* abbreviated parent hashes */
1184 if (add_again(sb
, &c
->abbrev_parent_hashes
))
1186 for (p
= commit
->parents
; p
; p
= p
->next
) {
1187 if (p
!= commit
->parents
)
1188 strbuf_addch(sb
, ' ');
1189 strbuf_addstr(sb
, find_unique_abbrev(
1190 p
->item
->object
.sha1
,
1191 c
->pretty_ctx
->abbrev
));
1193 c
->abbrev_parent_hashes
.len
= sb
->len
-
1194 c
->abbrev_parent_hashes
.off
;
1196 case 'm': /* left/right/bottom */
1197 strbuf_addstr(sb
, get_revision_mark(NULL
, commit
));
1200 load_ref_decorations(DECORATE_SHORT_REFS
);
1201 format_decorations(sb
, commit
, c
->auto_color
);
1203 case 'g': /* reflog info */
1204 switch(placeholder
[1]) {
1205 case 'd': /* reflog selector */
1207 if (c
->pretty_ctx
->reflog_info
)
1208 get_reflog_selector(sb
,
1209 c
->pretty_ctx
->reflog_info
,
1210 c
->pretty_ctx
->date_mode
,
1211 c
->pretty_ctx
->date_mode_explicit
,
1212 (placeholder
[1] == 'd'));
1214 case 's': /* reflog message */
1215 if (c
->pretty_ctx
->reflog_info
)
1216 get_reflog_message(sb
, c
->pretty_ctx
->reflog_info
);
1222 return format_reflog_person(sb
,
1224 c
->pretty_ctx
->reflog_info
,
1225 c
->pretty_ctx
->date_mode
);
1227 return 0; /* unknown %g placeholder */
1229 if (c
->pretty_ctx
->notes_message
) {
1230 strbuf_addstr(sb
, c
->pretty_ctx
->notes_message
);
1236 if (placeholder
[0] == 'G') {
1237 if (!c
->signature_check
.result
)
1238 check_commit_signature(c
->commit
, &(c
->signature_check
));
1239 switch (placeholder
[1]) {
1241 if (c
->signature_check
.gpg_output
)
1242 strbuf_addstr(sb
, c
->signature_check
.gpg_output
);
1245 switch (c
->signature_check
.result
) {
1250 strbuf_addch(sb
, c
->signature_check
.result
);
1254 if (c
->signature_check
.signer
)
1255 strbuf_addstr(sb
, c
->signature_check
.signer
);
1258 if (c
->signature_check
.key
)
1259 strbuf_addstr(sb
, c
->signature_check
.key
);
1268 /* For the rest we have to parse the commit header. */
1269 if (!c
->commit_header_parsed
)
1270 parse_commit_header(c
);
1272 switch (placeholder
[0]) {
1273 case 'a': /* author ... */
1274 return format_person_part(sb
, placeholder
[1],
1275 msg
+ c
->author
.off
, c
->author
.len
,
1276 c
->pretty_ctx
->date_mode
);
1277 case 'c': /* committer ... */
1278 return format_person_part(sb
, placeholder
[1],
1279 msg
+ c
->committer
.off
, c
->committer
.len
,
1280 c
->pretty_ctx
->date_mode
);
1281 case 'e': /* encoding */
1282 if (c
->commit_encoding
)
1283 strbuf_addstr(sb
, c
->commit_encoding
);
1285 case 'B': /* raw body */
1286 /* message_off is always left at the initial newline */
1287 strbuf_addstr(sb
, msg
+ c
->message_off
+ 1);
1291 /* Now we need to parse the commit message. */
1292 if (!c
->commit_message_parsed
)
1293 parse_commit_message(c
);
1295 switch (placeholder
[0]) {
1296 case 's': /* subject */
1297 format_subject(sb
, msg
+ c
->subject_off
, " ");
1299 case 'f': /* sanitized subject */
1300 format_sanitized_subject(sb
, msg
+ c
->subject_off
);
1302 case 'b': /* body */
1303 strbuf_addstr(sb
, msg
+ c
->body_off
);
1306 return 0; /* unknown placeholder */
1309 static size_t format_and_pad_commit(struct strbuf
*sb
, /* in UTF-8 */
1310 const char *placeholder
,
1311 struct format_commit_context
*c
)
1313 struct strbuf local_sb
= STRBUF_INIT
;
1314 int total_consumed
= 0, len
, padding
= c
->padding
;
1316 const char *start
= strrchr(sb
->buf
, '\n');
1320 occupied
= utf8_strnwidth(start
, -1, 1);
1321 padding
= (-padding
) - occupied
;
1324 int modifier
= *placeholder
== 'C';
1325 int consumed
= format_commit_one(&local_sb
, placeholder
, c
);
1326 total_consumed
+= consumed
;
1331 placeholder
+= consumed
;
1332 if (*placeholder
!= '%')
1337 len
= utf8_strnwidth(local_sb
.buf
, -1, 1);
1339 if (c
->flush_type
== flush_left_and_steal
) {
1340 const char *ch
= sb
->buf
+ sb
->len
- 1;
1341 while (len
> padding
&& ch
> sb
->buf
) {
1348 /* check for trailing ansi sequences */
1352 while (ch
- p
< 10 && *p
!= '\033')
1355 ch
+ 1 - p
!= display_mode_esc_sequence_len(p
))
1358 * got a good ansi sequence, put it back to
1359 * local_sb as we're cutting sb
1361 strbuf_insert(&local_sb
, 0, p
, ch
+ 1 - p
);
1364 strbuf_setlen(sb
, ch
+ 1 - sb
->buf
);
1365 c
->flush_type
= flush_left
;
1368 if (len
> padding
) {
1369 switch (c
->truncate
) {
1371 strbuf_utf8_replace(&local_sb
,
1372 0, len
- (padding
- 2),
1376 strbuf_utf8_replace(&local_sb
,
1378 len
- (padding
- 2),
1382 strbuf_utf8_replace(&local_sb
,
1383 padding
- 2, len
- (padding
- 2),
1389 strbuf_addbuf(sb
, &local_sb
);
1391 int sb_len
= sb
->len
, offset
= 0;
1392 if (c
->flush_type
== flush_left
)
1393 offset
= padding
- len
;
1394 else if (c
->flush_type
== flush_both
)
1395 offset
= (padding
- len
) / 2;
1397 * we calculate padding in columns, now
1398 * convert it back to chars
1400 padding
= padding
- len
+ local_sb
.len
;
1401 strbuf_grow(sb
, padding
);
1402 strbuf_setlen(sb
, sb_len
+ padding
);
1403 memset(sb
->buf
+ sb_len
, ' ', sb
->len
- sb_len
);
1404 memcpy(sb
->buf
+ sb_len
+ offset
, local_sb
.buf
,
1407 strbuf_release(&local_sb
);
1408 c
->flush_type
= no_flush
;
1409 return total_consumed
;
1412 static size_t format_commit_item(struct strbuf
*sb
, /* in UTF-8 */
1413 const char *placeholder
,
1420 ADD_LF_BEFORE_NON_EMPTY
,
1421 DEL_LF_BEFORE_EMPTY
,
1422 ADD_SP_BEFORE_NON_EMPTY
1425 switch (placeholder
[0]) {
1427 magic
= DEL_LF_BEFORE_EMPTY
;
1430 magic
= ADD_LF_BEFORE_NON_EMPTY
;
1433 magic
= ADD_SP_BEFORE_NON_EMPTY
;
1438 if (magic
!= NO_MAGIC
)
1442 if (((struct format_commit_context
*)context
)->flush_type
!= no_flush
)
1443 consumed
= format_and_pad_commit(sb
, placeholder
, context
);
1445 consumed
= format_commit_one(sb
, placeholder
, context
);
1446 if (magic
== NO_MAGIC
)
1449 if ((orig_len
== sb
->len
) && magic
== DEL_LF_BEFORE_EMPTY
) {
1450 while (sb
->len
&& sb
->buf
[sb
->len
- 1] == '\n')
1451 strbuf_setlen(sb
, sb
->len
- 1);
1452 } else if (orig_len
!= sb
->len
) {
1453 if (magic
== ADD_LF_BEFORE_NON_EMPTY
)
1454 strbuf_insert(sb
, orig_len
, "\n", 1);
1455 else if (magic
== ADD_SP_BEFORE_NON_EMPTY
)
1456 strbuf_insert(sb
, orig_len
, " ", 1);
1458 return consumed
+ 1;
1461 static size_t userformat_want_item(struct strbuf
*sb
, const char *placeholder
,
1464 struct userformat_want
*w
= context
;
1466 if (*placeholder
== '+' || *placeholder
== '-' || *placeholder
== ' ')
1469 switch (*placeholder
) {
1477 void userformat_find_requirements(const char *fmt
, struct userformat_want
*w
)
1479 struct strbuf dummy
= STRBUF_INIT
;
1486 strbuf_expand(&dummy
, fmt
, userformat_want_item
, w
);
1487 strbuf_release(&dummy
);
1490 void format_commit_message(const struct commit
*commit
,
1491 const char *format
, struct strbuf
*sb
,
1492 const struct pretty_print_context
*pretty_ctx
)
1494 struct format_commit_context context
;
1495 const char *output_enc
= pretty_ctx
->output_encoding
;
1496 const char *utf8
= "UTF-8";
1498 memset(&context
, 0, sizeof(context
));
1499 context
.commit
= commit
;
1500 context
.pretty_ctx
= pretty_ctx
;
1501 context
.wrap_start
= sb
->len
;
1503 * convert a commit message to UTF-8 first
1504 * as far as 'format_commit_item' assumes it in UTF-8
1506 context
.message
= logmsg_reencode(commit
,
1507 &context
.commit_encoding
,
1510 strbuf_expand(sb
, format
, format_commit_item
, &context
);
1511 rewrap_message_tail(sb
, &context
, 0, 0, 0);
1513 /* then convert a commit message to an actual output encoding */
1515 if (same_encoding(utf8
, output_enc
))
1518 if (context
.commit_encoding
&&
1519 !same_encoding(context
.commit_encoding
, utf8
))
1520 output_enc
= context
.commit_encoding
;
1525 char *out
= reencode_string_len(sb
->buf
, sb
->len
,
1526 output_enc
, utf8
, &outsz
);
1528 strbuf_attach(sb
, out
, outsz
, outsz
+ 1);
1531 free(context
.commit_encoding
);
1532 unuse_commit_buffer(commit
, context
.message
);
1535 static void pp_header(struct pretty_print_context
*pp
,
1536 const char *encoding
,
1537 const struct commit
*commit
,
1541 int parents_shown
= 0;
1544 const char *line
= *msg_p
;
1545 int linelen
= get_one_line(*msg_p
);
1555 if (pp
->fmt
== CMIT_FMT_RAW
) {
1556 strbuf_add(sb
, line
, linelen
);
1560 if (starts_with(line
, "parent ")) {
1562 die("bad parent line in commit");
1566 if (!parents_shown
) {
1567 unsigned num
= commit_list_count(commit
->parents
);
1568 /* with enough slop */
1569 strbuf_grow(sb
, num
* 50 + 20);
1570 add_merge_info(pp
, sb
, commit
);
1575 * MEDIUM == DEFAULT shows only author with dates.
1576 * FULL shows both authors but not dates.
1577 * FULLER shows both authors and dates.
1579 if (starts_with(line
, "author ")) {
1580 strbuf_grow(sb
, linelen
+ 80);
1581 pp_user_info(pp
, "Author", sb
, line
+ 7, encoding
);
1583 if (starts_with(line
, "committer ") &&
1584 (pp
->fmt
== CMIT_FMT_FULL
|| pp
->fmt
== CMIT_FMT_FULLER
)) {
1585 strbuf_grow(sb
, linelen
+ 80);
1586 pp_user_info(pp
, "Commit", sb
, line
+ 10, encoding
);
1591 void pp_title_line(struct pretty_print_context
*pp
,
1594 const char *encoding
,
1597 static const int max_length
= 78; /* per rfc2047 */
1598 struct strbuf title
;
1600 strbuf_init(&title
, 80);
1601 *msg_p
= format_subject(&title
, *msg_p
,
1602 pp
->preserve_subject
? "\n" : " ");
1604 strbuf_grow(sb
, title
.len
+ 1024);
1606 strbuf_addstr(sb
, pp
->subject
);
1607 if (needs_rfc2047_encoding(title
.buf
, title
.len
, RFC2047_SUBJECT
))
1608 add_rfc2047(sb
, title
.buf
, title
.len
,
1609 encoding
, RFC2047_SUBJECT
);
1611 strbuf_add_wrapped_bytes(sb
, title
.buf
, title
.len
,
1612 -last_line_length(sb
), 1, max_length
);
1614 strbuf_addbuf(sb
, &title
);
1616 strbuf_addch(sb
, '\n');
1618 if (need_8bit_cte
== 0) {
1620 for (i
= 0; i
< pp
->in_body_headers
.nr
; i
++) {
1621 if (has_non_ascii(pp
->in_body_headers
.items
[i
].string
)) {
1628 if (need_8bit_cte
> 0) {
1629 const char *header_fmt
=
1630 "MIME-Version: 1.0\n"
1631 "Content-Type: text/plain; charset=%s\n"
1632 "Content-Transfer-Encoding: 8bit\n";
1633 strbuf_addf(sb
, header_fmt
, encoding
);
1635 if (pp
->after_subject
) {
1636 strbuf_addstr(sb
, pp
->after_subject
);
1638 if (pp
->fmt
== CMIT_FMT_EMAIL
) {
1639 strbuf_addch(sb
, '\n');
1642 if (pp
->in_body_headers
.nr
) {
1644 for (i
= 0; i
< pp
->in_body_headers
.nr
; i
++) {
1645 strbuf_addstr(sb
, pp
->in_body_headers
.items
[i
].string
);
1646 free(pp
->in_body_headers
.items
[i
].string
);
1648 string_list_clear(&pp
->in_body_headers
, 0);
1649 strbuf_addch(sb
, '\n');
1652 strbuf_release(&title
);
1655 void pp_remainder(struct pretty_print_context
*pp
,
1662 const char *line
= *msg_p
;
1663 int linelen
= get_one_line(line
);
1669 if (is_empty_line(line
, &linelen
)) {
1672 if (pp
->fmt
== CMIT_FMT_SHORT
)
1677 strbuf_grow(sb
, linelen
+ indent
+ 20);
1679 memset(sb
->buf
+ sb
->len
, ' ', indent
);
1680 strbuf_setlen(sb
, sb
->len
+ indent
);
1682 strbuf_add(sb
, line
, linelen
);
1683 strbuf_addch(sb
, '\n');
1687 void pretty_print_commit(struct pretty_print_context
*pp
,
1688 const struct commit
*commit
,
1691 unsigned long beginning_of_body
;
1694 const char *reencoded
;
1695 const char *encoding
;
1696 int need_8bit_cte
= pp
->need_8bit_cte
;
1698 if (pp
->fmt
== CMIT_FMT_USERFORMAT
) {
1699 format_commit_message(commit
, user_format
, sb
, pp
);
1703 encoding
= get_log_output_encoding();
1704 msg
= reencoded
= logmsg_reencode(commit
, NULL
, encoding
);
1706 if (pp
->fmt
== CMIT_FMT_ONELINE
|| pp
->fmt
== CMIT_FMT_EMAIL
)
1710 * We need to check and emit Content-type: to mark it
1711 * as 8-bit if we haven't done so.
1713 if (pp
->fmt
== CMIT_FMT_EMAIL
&& need_8bit_cte
== 0) {
1716 for (in_body
= i
= 0; (ch
= msg
[i
]); i
++) {
1718 /* author could be non 7-bit ASCII but
1719 * the log may be so; skip over the
1720 * header part first.
1722 if (ch
== '\n' && msg
[i
+1] == '\n')
1725 else if (non_ascii(ch
)) {
1732 pp_header(pp
, encoding
, commit
, &msg
, sb
);
1733 if (pp
->fmt
!= CMIT_FMT_ONELINE
&& !pp
->subject
) {
1734 strbuf_addch(sb
, '\n');
1737 /* Skip excess blank lines at the beginning of body, if any... */
1738 msg
= skip_empty_lines(msg
);
1740 /* These formats treat the title line specially. */
1741 if (pp
->fmt
== CMIT_FMT_ONELINE
|| pp
->fmt
== CMIT_FMT_EMAIL
)
1742 pp_title_line(pp
, &msg
, sb
, encoding
, need_8bit_cte
);
1744 beginning_of_body
= sb
->len
;
1745 if (pp
->fmt
!= CMIT_FMT_ONELINE
)
1746 pp_remainder(pp
, &msg
, sb
, indent
);
1749 /* Make sure there is an EOLN for the non-oneline case */
1750 if (pp
->fmt
!= CMIT_FMT_ONELINE
)
1751 strbuf_addch(sb
, '\n');
1754 * The caller may append additional body text in e-mail
1755 * format. Make sure we did not strip the blank line
1756 * between the header and the body.
1758 if (pp
->fmt
== CMIT_FMT_EMAIL
&& sb
->len
<= beginning_of_body
)
1759 strbuf_addch(sb
, '\n');
1761 unuse_commit_buffer(commit
, reencoded
);
1764 void pp_commit_easy(enum cmit_fmt fmt
, const struct commit
*commit
,
1767 struct pretty_print_context pp
= {0};
1769 pretty_print_commit(&pp
, commit
, sb
);