Merge branch 'jt/cache-tree-avoid-lazy-fetch-during-merge'
[git/git.git] / pretty.c
CommitLineData
93fc05eb 1#include "cache.h"
b2141fc1 2#include "config.h"
93fc05eb 3#include "commit.h"
93fc05eb
JS
4#include "utf8.h"
5#include "diff.h"
6#include "revision.h"
c455c87c 7#include "string-list.h"
e0cbc397 8#include "mailmap.h"
3b3d443f 9#include "log-tree.h"
a97a7468 10#include "notes.h"
c002922a 11#include "color.h"
8f8f5476 12#include "reflog-walk.h"
f6667c5e 13#include "gpg-interface.h"
d9f31fbf 14#include "trailer.h"
93fc05eb 15
93fc05eb 16static char *user_format;
40957891
WP
17static struct cmt_fmt_map {
18 const char *name;
19 enum cmit_fmt format;
20 int is_tformat;
0893eec8 21 int expand_tabs_in_log;
2d7671ef
WP
22 int is_alias;
23 const char *user_format;
40957891 24} *commit_formats;
8028184e 25static size_t builtin_formats_len;
40957891 26static size_t commit_formats_len;
8028184e 27static size_t commit_formats_alloc;
40957891 28static struct cmt_fmt_map *find_commit_format(const char *sought);
93fc05eb 29
b9c7d6e4
JK
30int commit_format_is_empty(enum cmit_fmt fmt)
31{
32 return fmt == CMIT_FMT_USERFORMAT && !*user_format;
33}
34
36407548
NS
35static void save_user_format(struct rev_info *rev, const char *cp, int is_tformat)
36{
37 free(user_format);
38 user_format = xstrdup(cp);
39 if (is_tformat)
40 rev->use_terminator = 1;
41 rev->commit_format = CMIT_FMT_USERFORMAT;
42}
43
8028184e 44static int git_pretty_formats_config(const char *var, const char *value, void *cb)
93fc05eb 45{
8028184e
WP
46 struct cmt_fmt_map *commit_format = NULL;
47 const char *name;
48 const char *fmt;
93fc05eb 49 int i;
8028184e 50
95b567c7 51 if (!skip_prefix(var, "pretty.", &name))
8028184e
WP
52 return 0;
53
8028184e
WP
54 for (i = 0; i < builtin_formats_len; i++) {
55 if (!strcmp(commit_formats[i].name, name))
56 return 0;
57 }
58
59 for (i = builtin_formats_len; i < commit_formats_len; i++) {
60 if (!strcmp(commit_formats[i].name, name)) {
61 commit_format = &commit_formats[i];
62 break;
63 }
64 }
65
66 if (!commit_format) {
67 ALLOC_GROW(commit_formats, commit_formats_len+1,
68 commit_formats_alloc);
69 commit_format = &commit_formats[commit_formats_len];
95a2618f 70 memset(commit_format, 0, sizeof(*commit_format));
8028184e
WP
71 commit_formats_len++;
72 }
73
74 commit_format->name = xstrdup(name);
75 commit_format->format = CMIT_FMT_USERFORMAT;
a26bc613
TA
76 if (git_config_string(&fmt, var, value))
77 return -1;
78
e3f1da98
RS
79 if (skip_prefix(fmt, "format:", &fmt))
80 commit_format->is_tformat = 0;
81 else if (skip_prefix(fmt, "tformat:", &fmt) || strchr(fmt, '%'))
8028184e
WP
82 commit_format->is_tformat = 1;
83 else
84 commit_format->is_alias = 1;
85 commit_format->user_format = fmt;
86
87 return 0;
88}
89
40957891 90static void setup_commit_formats(void)
93fc05eb 91{
40957891 92 struct cmt_fmt_map builtin_formats[] = {
0893eec8 93 { "raw", CMIT_FMT_RAW, 0, 0 },
fe37a9c5 94 { "medium", CMIT_FMT_MEDIUM, 0, 8 },
0893eec8
JH
95 { "short", CMIT_FMT_SHORT, 0, 0 },
96 { "email", CMIT_FMT_EMAIL, 0, 0 },
9f23e040 97 { "mboxrd", CMIT_FMT_MBOXRD, 0, 0 },
fe37a9c5
JH
98 { "fuller", CMIT_FMT_FULLER, 0, 8 },
99 { "full", CMIT_FMT_FULL, 0, 8 },
0893eec8 100 { "oneline", CMIT_FMT_ONELINE, 1, 0 }
5a59a230
NTND
101 /*
102 * Please update $__git_log_pretty_formats in
103 * git-completion.bash when you add new formats.
104 */
4da45bef 105 };
40957891 106 commit_formats_len = ARRAY_SIZE(builtin_formats);
8028184e
WP
107 builtin_formats_len = commit_formats_len;
108 ALLOC_GROW(commit_formats, commit_formats_len, commit_formats_alloc);
921d49be
RS
109 COPY_ARRAY(commit_formats, builtin_formats,
110 ARRAY_SIZE(builtin_formats));
8028184e
WP
111
112 git_config(git_pretty_formats_config, NULL);
40957891
WP
113}
114
2d7671ef
WP
115static struct cmt_fmt_map *find_commit_format_recursive(const char *sought,
116 const char *original,
117 int num_redirections)
40957891
WP
118{
119 struct cmt_fmt_map *found = NULL;
120 size_t found_match_len = 0;
121 int i;
122
2d7671ef
WP
123 if (num_redirections >= commit_formats_len)
124 die("invalid --pretty format: "
125 "'%s' references an alias which points to itself",
126 original);
40957891
WP
127
128 for (i = 0; i < commit_formats_len; i++) {
129 size_t match_len;
130
59556548 131 if (!starts_with(commit_formats[i].name, sought))
40957891
WP
132 continue;
133
134 match_len = strlen(commit_formats[i].name);
135 if (found == NULL || found_match_len > match_len) {
136 found = &commit_formats[i];
137 found_match_len = match_len;
138 }
139 }
2d7671ef
WP
140
141 if (found && found->is_alias) {
142 found = find_commit_format_recursive(found->user_format,
143 original,
144 num_redirections+1);
145 }
146
40957891
WP
147 return found;
148}
149
2d7671ef
WP
150static struct cmt_fmt_map *find_commit_format(const char *sought)
151{
152 if (!commit_formats)
153 setup_commit_formats();
154
155 return find_commit_format_recursive(sought, sought, 0);
156}
157
40957891
WP
158void get_commit_format(const char *arg, struct rev_info *rev)
159{
160 struct cmt_fmt_map *commit_format;
93fc05eb 161
4da45bef 162 rev->use_terminator = 0;
c75e7ad2 163 if (!arg) {
4da45bef
JH
164 rev->commit_format = CMIT_FMT_DEFAULT;
165 return;
166 }
e3f1da98
RS
167 if (skip_prefix(arg, "format:", &arg)) {
168 save_user_format(rev, arg, 0);
4da45bef 169 return;
93fc05eb 170 }
40957891 171
e3f1da98 172 if (!*arg || skip_prefix(arg, "tformat:", &arg) || strchr(arg, '%')) {
36407548
NS
173 save_user_format(rev, arg, 1);
174 return;
175 }
93fc05eb 176
40957891
WP
177 commit_format = find_commit_format(arg);
178 if (!commit_format)
179 die("invalid --pretty format: %s", arg);
180
181 rev->commit_format = commit_format->format;
182 rev->use_terminator = commit_format->is_tformat;
0893eec8 183 rev->expand_tabs_in_log_default = commit_format->expand_tabs_in_log;
8028184e
WP
184 if (commit_format->format == CMIT_FMT_USERFORMAT) {
185 save_user_format(rev, commit_format->user_format,
186 commit_format->is_tformat);
187 }
93fc05eb
JS
188}
189
190/*
191 * Generic support for pretty-printing the header
192 */
193static int get_one_line(const char *msg)
194{
195 int ret = 0;
196
197 for (;;) {
198 char c = *msg++;
199 if (!c)
200 break;
201 ret++;
202 if (c == '\n')
203 break;
204 }
205 return ret;
206}
207
208/* High bit set, or ISO-2022-INT */
cc571142 209static int non_ascii(int ch)
93fc05eb 210{
c2e9364a 211 return !isascii(ch) || ch == '\033';
93fc05eb
JS
212}
213
28e9cf65
JS
214int has_non_ascii(const char *s)
215{
216 int ch;
217 if (!s)
218 return 0;
219 while ((ch = *s++) != '\0') {
220 if (non_ascii(ch))
221 return 1;
222 }
223 return 0;
224}
225
4d03c18a
JK
226static int is_rfc822_special(char ch)
227{
228 switch (ch) {
229 case '(':
230 case ')':
231 case '<':
232 case '>':
233 case '[':
234 case ']':
235 case ':':
236 case ';':
237 case '@':
238 case ',':
239 case '.':
240 case '"':
241 case '\\':
242 return 1;
243 default:
244 return 0;
245 }
246}
247
41dd00ba 248static int needs_rfc822_quoting(const char *s, int len)
4d03c18a
JK
249{
250 int i;
251 for (i = 0; i < len; i++)
252 if (is_rfc822_special(s[i]))
253 return 1;
254 return 0;
255}
256
f9b7204b
JS
257static int last_line_length(struct strbuf *sb)
258{
259 int i;
260
261 /* How many bytes are already used on the last line? */
262 for (i = sb->len - 1; i >= 0; i--)
263 if (sb->buf[i] == '\n')
264 break;
265 return sb->len - (i + 1);
266}
267
4d03c18a
JK
268static void add_rfc822_quoted(struct strbuf *out, const char *s, int len)
269{
270 int i;
271
272 /* just a guess, we may have to also backslash-quote */
273 strbuf_grow(out, len + 2);
274
275 strbuf_addch(out, '"');
276 for (i = 0; i < len; i++) {
277 switch (s[i]) {
278 case '"':
279 case '\\':
280 strbuf_addch(out, '\\');
281 /* fall through */
282 default:
283 strbuf_addch(out, s[i]);
284 }
285 }
286 strbuf_addch(out, '"');
287}
288
0fcec2ce
JS
289enum rfc2047_type {
290 RFC2047_SUBJECT,
78273520 291 RFC2047_ADDRESS
0fcec2ce
JS
292};
293
294static int is_rfc2047_special(char ch, enum rfc2047_type type)
93fc05eb 295{
0fcec2ce
JS
296 /*
297 * rfc2047, section 4.2:
298 *
299 * 8-bit values which correspond to printable ASCII characters other
300 * than "=", "?", and "_" (underscore), MAY be represented as those
301 * characters. (But see section 5 for restrictions.) In
302 * particular, SPACE and TAB MUST NOT be represented as themselves
303 * within encoded words.
304 */
305
306 /*
307 * rule out non-ASCII characters and non-printable characters (the
308 * non-ASCII check should be redundant as isprint() is not localized
309 * and only knows about ASCII, but be defensive about that)
310 */
311 if (non_ascii(ch) || !isprint(ch))
312 return 1;
313
314 /*
315 * rule out special printable characters (' ' should be the only
316 * whitespace character considered printable, but be defensive and use
317 * isspace())
318 */
319 if (isspace(ch) || ch == '=' || ch == '?' || ch == '_')
94f6cdf6
JS
320 return 1;
321
0fcec2ce
JS
322 /*
323 * rfc2047, section 5.3:
324 *
325 * As a replacement for a 'word' entity within a 'phrase', for example,
326 * one that precedes an address in a From, To, or Cc header. The ABNF
327 * definition for 'phrase' from RFC 822 thus becomes:
328 *
329 * phrase = 1*( encoded-word / word )
330 *
331 * In this case the set of characters that may be used in a "Q"-encoded
332 * 'encoded-word' is restricted to: <upper and lower case ASCII
333 * letters, decimal digits, "!", "*", "+", "-", "/", "=", and "_"
334 * (underscore, ASCII 95.)>. An 'encoded-word' that appears within a
335 * 'phrase' MUST be separated from any adjacent 'word', 'text' or
336 * 'special' by 'linear-white-space'.
337 */
338
339 if (type != RFC2047_ADDRESS)
340 return 0;
341
342 /* '=' and '_' are special cases and have been checked above */
343 return !(isalnum(ch) || ch == '!' || ch == '*' || ch == '+' || ch == '-' || ch == '/');
93fc05eb
JS
344}
345
da55ff3d 346static int needs_rfc2047_encoding(const char *line, int len)
93fc05eb 347{
a1f6baa5 348 int i;
93fc05eb
JS
349
350 for (i = 0; i < len; i++) {
351 int ch = line[i];
c22e7de3 352 if (non_ascii(ch) || ch == '\n')
41dd00ba 353 return 1;
93fc05eb 354 if ((i + 1 < len) && (ch == '=' && line[i+1] == '?'))
41dd00ba 355 return 1;
93fc05eb 356 }
93fc05eb 357
41dd00ba
JS
358 return 0;
359}
360
6cd3c053 361static void add_rfc2047(struct strbuf *sb, const char *line, size_t len,
41dd00ba
JS
362 const char *encoding, enum rfc2047_type type)
363{
364 static const int max_encoded_length = 76; /* per rfc2047 */
365 int i;
366 int line_len = last_line_length(sb);
367
93fc05eb
JS
368 strbuf_grow(sb, len * 3 + strlen(encoding) + 100);
369 strbuf_addf(sb, "=?%s?q?", encoding);
a1f6baa5 370 line_len += strlen(encoding) + 5; /* 5 for =??q? */
6cd3c053
KS
371
372 while (len) {
373 /*
374 * RFC 2047, section 5 (3):
375 *
376 * Each 'encoded-word' MUST represent an integral number of
377 * characters. A multi-octet character may not be split across
378 * adjacent 'encoded- word's.
379 */
380 const unsigned char *p = (const unsigned char *)line;
381 int chrlen = mbs_chrlen(&line, &len, encoding);
382 int is_special = (chrlen > 1) || is_rfc2047_special(*p, type);
383
384 /* "=%02X" * chrlen, or the byte itself */
385 const char *encoded_fmt = is_special ? "=%02X" : "%c";
386 int encoded_len = is_special ? 3 * chrlen : 1;
94f6cdf6
JS
387
388 /*
389 * According to RFC 2047, we could encode the special character
390 * ' ' (space) with '_' (underscore) for readability. But many
391 * programs do not understand this and just leave the
392 * underscore in place. Thus, we do nothing special here, which
393 * causes ' ' to be encoded as '=20', avoiding this problem.
394 */
a1f6baa5 395
6cd3c053
KS
396 if (line_len + encoded_len + 2 > max_encoded_length) {
397 /* It won't fit with trailing "?=" --- break the line */
a1f6baa5
JK
398 strbuf_addf(sb, "?=\n =?%s?q?", encoding);
399 line_len = strlen(encoding) + 5 + 1; /* =??q? plus SP */
400 }
401
6cd3c053
KS
402 for (i = 0; i < chrlen; i++)
403 strbuf_addf(sb, encoded_fmt, p[i]);
404 line_len += encoded_len;
93fc05eb 405 }
93fc05eb
JS
406 strbuf_addstr(sb, "?=");
407}
408
d1053246 409const char *show_ident_date(const struct ident_split *ident,
a5481a6c 410 const struct date_mode *mode)
9dbe7c3d 411{
dddbad72 412 timestamp_t date = 0;
3f419d45 413 long tz = 0;
9dbe7c3d
RS
414
415 if (ident->date_begin && ident->date_end)
1aeb7e75 416 date = parse_timestamp(ident->date_begin, NULL, 10);
1dca155f
JK
417 if (date_overflows(date))
418 date = 0;
419 else {
420 if (ident->tz_begin && ident->tz_end)
421 tz = strtol(ident->tz_begin, NULL, 10);
3f419d45 422 if (tz >= INT_MAX || tz <= INT_MIN)
1dca155f
JK
423 tz = 0;
424 }
9dbe7c3d
RS
425 return show_date(date, tz, mode);
426}
427
10f2fbff 428void pp_user_info(struct pretty_print_context *pp,
6bf13944
JK
429 const char *what, struct strbuf *sb,
430 const char *line, const char *encoding)
93fc05eb 431{
3c020bd5 432 struct ident_split ident;
9dbe7c3d 433 char *line_end;
dffd325f
AP
434 const char *mailbuf, *namebuf;
435 size_t namelen, maillen;
41dd00ba 436 int max_length = 78; /* per rfc2822 */
93fc05eb 437
6bf13944 438 if (pp->fmt == CMIT_FMT_ONELINE)
93fc05eb 439 return;
3c020bd5 440
30e77bcb
RS
441 line_end = strchrnul(line, '\n');
442 if (split_ident_line(&ident, line, line_end - line))
93fc05eb 443 return;
3c020bd5 444
dffd325f
AP
445 mailbuf = ident.mail_begin;
446 maillen = ident.mail_end - ident.mail_begin;
447 namebuf = ident.name_begin;
448 namelen = ident.name_end - ident.name_begin;
449
450 if (pp->mailmap)
451 map_user(pp->mailmap, &mailbuf, &maillen, &namebuf, &namelen);
452
9f23e040 453 if (cmit_fmt_is_mail(pp->fmt)) {
662cc30c 454 if (pp->from_ident && ident_cmp(pp->from_ident, &ident)) {
a9080475
JK
455 struct strbuf buf = STRBUF_INIT;
456
457 strbuf_addstr(&buf, "From: ");
458 strbuf_add(&buf, namebuf, namelen);
459 strbuf_addstr(&buf, " <");
460 strbuf_add(&buf, mailbuf, maillen);
461 strbuf_addstr(&buf, ">\n");
462 string_list_append(&pp->in_body_headers,
463 strbuf_detach(&buf, NULL));
464
465 mailbuf = pp->from_ident->mail_begin;
466 maillen = pp->from_ident->mail_end - mailbuf;
467 namebuf = pp->from_ident->name_begin;
468 namelen = pp->from_ident->name_end - namebuf;
469 }
470
93fc05eb 471 strbuf_addstr(sb, "From: ");
da55ff3d 472 if (needs_rfc2047_encoding(namebuf, namelen)) {
a0511b39 473 add_rfc2047(sb, namebuf, namelen,
dffd325f 474 encoding, RFC2047_ADDRESS);
41dd00ba 475 max_length = 76; /* per rfc2047 */
a0511b39 476 } else if (needs_rfc822_quoting(namebuf, namelen)) {
4d03c18a 477 struct strbuf quoted = STRBUF_INIT;
a0511b39 478 add_rfc822_quoted(&quoted, namebuf, namelen);
41dd00ba
JS
479 strbuf_add_wrapped_bytes(sb, quoted.buf, quoted.len,
480 -6, 1, max_length);
4d03c18a 481 strbuf_release(&quoted);
41dd00ba 482 } else {
a0511b39 483 strbuf_add_wrapped_bytes(sb, namebuf, namelen,
dffd325f 484 -6, 1, max_length);
4d03c18a 485 }
dffd325f 486
97a17e77
RS
487 if (max_length <
488 last_line_length(sb) + strlen(" <") + maillen + strlen(">"))
489 strbuf_addch(sb, '\n');
a0511b39 490 strbuf_addf(sb, " <%.*s>\n", (int)maillen, mailbuf);
93fc05eb 491 } else {
a0511b39
RS
492 strbuf_addf(sb, "%s: %.*s%.*s <%.*s>\n", what,
493 (pp->fmt == CMIT_FMT_FULLER) ? 4 : 0, " ",
494 (int)namelen, namebuf, (int)maillen, mailbuf);
93fc05eb 495 }
dffd325f 496
6bf13944 497 switch (pp->fmt) {
93fc05eb 498 case CMIT_FMT_MEDIUM:
9dbe7c3d 499 strbuf_addf(sb, "Date: %s\n",
a5481a6c 500 show_ident_date(&ident, &pp->date_mode));
93fc05eb
JS
501 break;
502 case CMIT_FMT_EMAIL:
9f23e040 503 case CMIT_FMT_MBOXRD:
9dbe7c3d 504 strbuf_addf(sb, "Date: %s\n",
a5481a6c 505 show_ident_date(&ident, DATE_MODE(RFC2822)));
93fc05eb
JS
506 break;
507 case CMIT_FMT_FULLER:
9dbe7c3d 508 strbuf_addf(sb, "%sDate: %s\n", what,
a5481a6c 509 show_ident_date(&ident, &pp->date_mode));
93fc05eb
JS
510 break;
511 default:
512 /* notin' */
513 break;
514 }
515}
516
77356122 517static int is_blank_line(const char *line, int *len_p)
93fc05eb
JS
518{
519 int len = *len_p;
35b2fa5b 520 while (len && isspace(line[len - 1]))
93fc05eb
JS
521 len--;
522 *len_p = len;
523 return !len;
524}
525
77356122 526const char *skip_blank_lines(const char *msg)
a0109668
RS
527{
528 for (;;) {
529 int linelen = get_one_line(msg);
530 int ll = linelen;
531 if (!linelen)
532 break;
77356122 533 if (!is_blank_line(msg, &ll))
a0109668
RS
534 break;
535 msg += linelen;
536 }
537 return msg;
538}
539
6bf13944
JK
540static void add_merge_info(const struct pretty_print_context *pp,
541 struct strbuf *sb, const struct commit *commit)
93fc05eb
JS
542{
543 struct commit_list *parent = commit->parents;
544
9f23e040 545 if ((pp->fmt == CMIT_FMT_ONELINE) || (cmit_fmt_is_mail(pp->fmt)) ||
93fc05eb
JS
546 !parent || !parent->next)
547 return;
548
549 strbuf_addstr(sb, "Merge:");
550
551 while (parent) {
a94bb683
RS
552 struct object_id *oidp = &parent->item->object.oid;
553 strbuf_addch(sb, ' ');
6bf13944 554 if (pp->abbrev)
30e677e0 555 strbuf_add_unique_abbrev(sb, oidp, pp->abbrev);
a94bb683
RS
556 else
557 strbuf_addstr(sb, oid_to_hex(oidp));
93fc05eb 558 parent = parent->next;
93fc05eb
JS
559 }
560 strbuf_addch(sb, '\n');
561}
562
fe6eb7f2 563static char *get_header(const char *msg, const char *key)
93fc05eb 564{
fe6eb7f2
JK
565 size_t len;
566 const char *v = find_commit_header(msg, key, &len);
567 return v ? xmemdupz(v, len) : NULL;
93fc05eb
JS
568}
569
570static char *replace_encoding_header(char *buf, const char *encoding)
571{
f285a2d7 572 struct strbuf tmp = STRBUF_INIT;
93fc05eb
JS
573 size_t start, len;
574 char *cp = buf;
575
576 /* guess if there is an encoding header before a \n\n */
68d6d6eb 577 while (!starts_with(cp, "encoding ")) {
93fc05eb
JS
578 cp = strchr(cp, '\n');
579 if (!cp || *++cp == '\n')
580 return buf;
581 }
582 start = cp - buf;
583 cp = strchr(cp, '\n');
584 if (!cp)
585 return buf; /* should not happen but be defensive */
586 len = cp + 1 - (buf + start);
587
93fc05eb
JS
588 strbuf_attach(&tmp, buf, strlen(buf), strlen(buf) + 1);
589 if (is_encoding_utf8(encoding)) {
590 /* we have re-coded to UTF-8; drop the header */
591 strbuf_remove(&tmp, start, len);
592 } else {
593 /* just replaces XXXX in 'encoding XXXX\n' */
594 strbuf_splice(&tmp, start + strlen("encoding "),
595 len - strlen("encoding \n"),
596 encoding, strlen(encoding));
597 }
598 return strbuf_detach(&tmp, NULL);
599}
600
424510ed
SB
601const char *repo_logmsg_reencode(struct repository *r,
602 const struct commit *commit,
603 char **commit_encoding,
604 const char *output_encoding)
93fc05eb 605{
330db18c 606 static const char *utf8 = "UTF-8";
93fc05eb
JS
607 const char *use_encoding;
608 char *encoding;
424510ed 609 const char *msg = repo_get_commit_buffer(r, commit, NULL);
93fc05eb
JS
610 char *out;
611
5a10d236
NTND
612 if (!output_encoding || !*output_encoding) {
613 if (commit_encoding)
fe6eb7f2 614 *commit_encoding = get_header(msg, "encoding");
dd0d388c 615 return msg;
5a10d236 616 }
fe6eb7f2 617 encoding = get_header(msg, "encoding");
5a10d236
NTND
618 if (commit_encoding)
619 *commit_encoding = encoding;
93fc05eb 620 use_encoding = encoding ? encoding : utf8;
be5c9fb9
JK
621 if (same_encoding(use_encoding, output_encoding)) {
622 /*
623 * No encoding work to be done. If we have no encoding header
624 * at all, then there's nothing to do, and we can return the
625 * message verbatim (whether newly allocated or not).
626 */
627 if (!encoding)
628 return msg;
629
630 /*
631 * Otherwise, we still want to munge the encoding header in the
632 * result, which will be done by modifying the buffer. If we
633 * are using a fresh copy, we can reuse it. But if we are using
b66103c3
JK
634 * the cached copy from get_commit_buffer, we need to duplicate it
635 * to avoid munging the cached copy.
be5c9fb9 636 */
424510ed 637 if (msg == get_cached_commit_buffer(r, commit, NULL))
b66103c3
JK
638 out = xstrdup(msg);
639 else
640 out = (char *)msg;
be5c9fb9
JK
641 }
642 else {
643 /*
644 * There's actual encoding work to do. Do the reencoding, which
645 * still leaves the header to be replaced in the next step. At
646 * this point, we are done with msg. If we allocated a fresh
647 * copy, we can free it.
648 */
649 out = reencode_string(msg, output_encoding, use_encoding);
b66103c3 650 if (out)
424510ed 651 repo_unuse_commit_buffer(r, commit, msg);
be5c9fb9
JK
652 }
653
654 /*
655 * This replacement actually consumes the buffer we hand it, so we do
656 * not have to worry about freeing the old "out" here.
657 */
93fc05eb
JS
658 if (out)
659 out = replace_encoding_header(out, output_encoding);
660
5a10d236
NTND
661 if (!commit_encoding)
662 free(encoding);
dd0d388c
JK
663 /*
664 * If the re-encoding failed, out might be NULL here; in that
665 * case we just return the commit message verbatim.
666 */
667 return out ? out : msg;
668}
669
ea02ffa3
AP
670static int mailmap_name(const char **email, size_t *email_len,
671 const char **name, size_t *name_len)
e0cbc397 672{
c455c87c 673 static struct string_list *mail_map;
e0cbc397
JS
674 if (!mail_map) {
675 mail_map = xcalloc(1, sizeof(*mail_map));
d551a488 676 read_mailmap(mail_map, NULL);
e0cbc397 677 }
d20d654f 678 return mail_map->nr && map_user(mail_map, email, email_len, name, name_len);
e0cbc397
JS
679}
680
c3a670de 681static size_t format_person_part(struct strbuf *sb, char part,
a5481a6c
JK
682 const char *msg, int len,
683 const struct date_mode *dmode)
93fc05eb 684{
c3a670de
MC
685 /* currently all placeholders have same length */
686 const int placeholder_len = 2;
4b340cfa 687 struct ident_split s;
ea02ffa3
AP
688 const char *name, *mail;
689 size_t maillen, namelen;
93fc05eb 690
4b340cfa 691 if (split_ident_line(&s, msg, len) < 0)
c3a670de
MC
692 goto skip;
693
ea02ffa3
AP
694 name = s.name_begin;
695 namelen = s.name_end - s.name_begin;
696 mail = s.mail_begin;
697 maillen = s.mail_end - s.mail_begin;
698
699 if (part == 'N' || part == 'E') /* mailmap lookup */
700 mailmap_name(&mail, &maillen, &name, &namelen);
e0cbc397 701 if (part == 'n' || part == 'N') { /* name */
ea02ffa3 702 strbuf_add(sb, name, namelen);
c3a670de 703 return placeholder_len;
cde75e59 704 }
d20d654f 705 if (part == 'e' || part == 'E') { /* email */
ea02ffa3 706 strbuf_add(sb, mail, maillen);
c3a670de 707 return placeholder_len;
cde75e59 708 }
93fc05eb 709
4b340cfa 710 if (!s.date_begin)
c3a670de 711 goto skip;
93fc05eb 712
cde75e59 713 if (part == 't') { /* date, UNIX timestamp */
4b340cfa 714 strbuf_add(sb, s.date_begin, s.date_end - s.date_begin);
c3a670de 715 return placeholder_len;
cde75e59 716 }
93fc05eb 717
cde75e59
RS
718 switch (part) {
719 case 'd': /* date */
9dbe7c3d 720 strbuf_addstr(sb, show_ident_date(&s, dmode));
c3a670de 721 return placeholder_len;
cde75e59 722 case 'D': /* date, RFC2822 style */
a5481a6c 723 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(RFC2822)));
c3a670de 724 return placeholder_len;
cde75e59 725 case 'r': /* date, relative */
a5481a6c 726 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(RELATIVE)));
c3a670de 727 return placeholder_len;
466fb674 728 case 'i': /* date, ISO 8601-like */
a5481a6c 729 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(ISO8601)));
c3a670de 730 return placeholder_len;
466fb674 731 case 'I': /* date, ISO 8601 strict */
a5481a6c 732 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(ISO8601_STRICT)));
466fb674 733 return placeholder_len;
cde75e59 734 }
c3a670de
MC
735
736skip:
737 /*
4b340cfa
JH
738 * reading from either a bogus commit, or a reflog entry with
739 * %gn, %ge, etc.; 'sb' cannot be updated, but we still need
740 * to compute a valid return value.
c3a670de
MC
741 */
742 if (part == 'n' || part == 'e' || part == 't' || part == 'd'
743 || part == 'D' || part == 'r' || part == 'i')
744 return placeholder_len;
745
746 return 0; /* unknown placeholder */
93fc05eb
JS
747}
748
f29d5958
RS
749struct chunk {
750 size_t off;
751 size_t len;
752};
753
a5752342
NTND
754enum flush_type {
755 no_flush,
756 flush_right,
757 flush_left,
1640632b 758 flush_left_and_steal,
a5752342
NTND
759 flush_both
760};
761
a7f01c6b
NTND
762enum trunc_type {
763 trunc_none,
764 trunc_left,
765 trunc_middle,
766 trunc_right
767};
768
f29d5958
RS
769struct format_commit_context {
770 const struct commit *commit;
dd2e794a 771 const struct pretty_print_context *pretty_ctx;
f53bd743
RS
772 unsigned commit_header_parsed:1;
773 unsigned commit_message_parsed:1;
ffb6d7d5 774 struct signature_check signature_check;
a5752342 775 enum flush_type flush_type;
a7f01c6b 776 enum trunc_type truncate;
b000c59b 777 const char *message;
0940a76d 778 char *commit_encoding;
02edd56b 779 size_t width, indent1, indent2;
a95f067e 780 int auto_color;
a5752342 781 int padding;
f29d5958
RS
782
783 /* These offsets are relative to the start of the commit message. */
f29d5958
RS
784 struct chunk author;
785 struct chunk committer;
f53bd743
RS
786 size_t message_off;
787 size_t subject_off;
f29d5958 788 size_t body_off;
b9c62321
RS
789
790 /* The following ones are relative to the result struct strbuf. */
02edd56b 791 size_t wrap_start;
f29d5958
RS
792};
793
794static void parse_commit_header(struct format_commit_context *context)
93fc05eb 795{
177b29dc 796 const char *msg = context->message;
93fc05eb 797 int i;
f29d5958 798
f53bd743 799 for (i = 0; msg[i]; i++) {
e3f1da98 800 const char *name;
f29d5958
RS
801 int eol;
802 for (eol = i; msg[eol] && msg[eol] != '\n'; eol++)
803 ; /* do nothing */
804
f29d5958 805 if (i == eol) {
f53bd743 806 break;
e3f1da98
RS
807 } else if (skip_prefix(msg + i, "author ", &name)) {
808 context->author.off = name - msg;
809 context->author.len = msg + eol - name;
810 } else if (skip_prefix(msg + i, "committer ", &name)) {
811 context->committer.off = name - msg;
812 context->committer.len = msg + eol - name;
f29d5958
RS
813 }
814 i = eol;
815 }
f53bd743 816 context->message_off = i;
f29d5958
RS
817 context->commit_header_parsed = 1;
818}
819
46d164b0
SB
820static int istitlechar(char c)
821{
822 return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
823 (c >= '0' && c <= '9') || c == '.' || c == '_';
824}
825
826static void format_sanitized_subject(struct strbuf *sb, const char *msg)
827{
828 size_t trimlen;
871d21d4 829 size_t start_len = sb->len;
46d164b0
SB
830 int space = 2;
831
832 for (; *msg && *msg != '\n'; msg++) {
833 if (istitlechar(*msg)) {
834 if (space == 1)
835 strbuf_addch(sb, '-');
836 space = 0;
837 strbuf_addch(sb, *msg);
838 if (*msg == '.')
839 while (*(msg+1) == '.')
840 msg++;
841 } else
842 space |= 1;
843 }
844
845 /* trim any trailing '.' or '-' characters */
846 trimlen = 0;
871d21d4
SB
847 while (sb->len - trimlen > start_len &&
848 (sb->buf[sb->len - 1 - trimlen] == '.'
849 || sb->buf[sb->len - 1 - trimlen] == '-'))
46d164b0
SB
850 trimlen++;
851 strbuf_remove(sb, sb->len - trimlen, trimlen);
852}
853
cec08717
RS
854const char *format_subject(struct strbuf *sb, const char *msg,
855 const char *line_separator)
88c44735
RS
856{
857 int first = 1;
858
859 for (;;) {
860 const char *line = msg;
861 int linelen = get_one_line(line);
862
863 msg += linelen;
77356122 864 if (!linelen || is_blank_line(line, &linelen))
88c44735
RS
865 break;
866
f53bd743
RS
867 if (!sb)
868 continue;
88c44735
RS
869 strbuf_grow(sb, linelen + 2);
870 if (!first)
871 strbuf_addstr(sb, line_separator);
872 strbuf_add(sb, line, linelen);
873 first = 0;
874 }
875 return msg;
876}
877
f53bd743
RS
878static void parse_commit_message(struct format_commit_context *c)
879{
177b29dc
PN
880 const char *msg = c->message + c->message_off;
881 const char *start = c->message;
f53bd743 882
77356122 883 msg = skip_blank_lines(msg);
f53bd743
RS
884 c->subject_off = msg - start;
885
886 msg = format_subject(NULL, msg, NULL);
77356122 887 msg = skip_blank_lines(msg);
f53bd743
RS
888 c->body_off = msg - start;
889
890 c->commit_message_parsed = 1;
891}
892
02edd56b
RS
893static void strbuf_wrap(struct strbuf *sb, size_t pos,
894 size_t width, size_t indent1, size_t indent2)
895{
896 struct strbuf tmp = STRBUF_INIT;
897
898 if (pos)
899 strbuf_add(&tmp, sb->buf, pos);
900 strbuf_add_wrapped_text(&tmp, sb->buf + pos,
901 (int) indent1, (int) indent2, (int) width);
902 strbuf_swap(&tmp, sb);
903 strbuf_release(&tmp);
904}
905
906static void rewrap_message_tail(struct strbuf *sb,
907 struct format_commit_context *c,
908 size_t new_width, size_t new_indent1,
909 size_t new_indent2)
910{
911 if (c->width == new_width && c->indent1 == new_indent1 &&
912 c->indent2 == new_indent2)
913 return;
32ca4249 914 if (c->wrap_start < sb->len)
02edd56b
RS
915 strbuf_wrap(sb, c->wrap_start, c->width, c->indent1, c->indent2);
916 c->wrap_start = sb->len;
917 c->width = new_width;
918 c->indent1 = new_indent1;
919 c->indent2 = new_indent2;
920}
921
cd1957f5
JK
922static int format_reflog_person(struct strbuf *sb,
923 char part,
924 struct reflog_walk_info *log,
a5481a6c 925 const struct date_mode *dmode)
cd1957f5
JK
926{
927 const char *ident;
928
929 if (!log)
930 return 2;
931
932 ident = get_reflog_ident(log);
933 if (!ident)
934 return 2;
935
936 return format_person_part(sb, part, ident, strlen(ident), dmode);
937}
938
fcabc2d9
NTND
939static size_t parse_color(struct strbuf *sb, /* in UTF-8 */
940 const char *placeholder,
941 struct format_commit_context *c)
942{
e3f1da98 943 const char *rest = placeholder;
18fb7ffc 944 const char *basic_color = NULL;
e3f1da98 945
fcabc2d9
NTND
946 if (placeholder[1] == '(') {
947 const char *begin = placeholder + 2;
948 const char *end = strchr(begin, ')');
949 char color[COLOR_MAXLEN];
950
951 if (!end)
952 return 0;
18fb7ffc 953
e3f1da98 954 if (skip_prefix(begin, "auto,", &begin)) {
fcabc2d9
NTND
955 if (!want_color(c->pretty_ctx->color))
956 return end - placeholder + 1;
18fb7ffc
JK
957 } else if (skip_prefix(begin, "always,", &begin)) {
958 /* nothing to do; we do not respect want_color at all */
959 } else {
960 /* the default is the same as "auto" */
961 if (!want_color(c->pretty_ctx->color))
962 return end - placeholder + 1;
fcabc2d9 963 }
18fb7ffc 964
f6c5a296
JK
965 if (color_parse_mem(begin, end - begin, color) < 0)
966 die(_("unable to parse --pretty format"));
fcabc2d9
NTND
967 strbuf_addstr(sb, color);
968 return end - placeholder + 1;
969 }
18fb7ffc
JK
970
971 /*
972 * We handle things like "%C(red)" above; for historical reasons, there
973 * are a few colors that can be specified without parentheses (and
974 * they cannot support things like "auto" or "always" at all).
975 */
e3f1da98 976 if (skip_prefix(placeholder + 1, "red", &rest))
18fb7ffc 977 basic_color = GIT_COLOR_RED;
e3f1da98 978 else if (skip_prefix(placeholder + 1, "green", &rest))
18fb7ffc 979 basic_color = GIT_COLOR_GREEN;
e3f1da98 980 else if (skip_prefix(placeholder + 1, "blue", &rest))
18fb7ffc 981 basic_color = GIT_COLOR_BLUE;
e3f1da98 982 else if (skip_prefix(placeholder + 1, "reset", &rest))
18fb7ffc
JK
983 basic_color = GIT_COLOR_RESET;
984
985 if (basic_color && want_color(c->pretty_ctx->color))
986 strbuf_addstr(sb, basic_color);
987
e3f1da98 988 return rest - placeholder;
fcabc2d9
NTND
989}
990
9a1180fc 991static size_t parse_padding_placeholder(const char *placeholder,
a5752342
NTND
992 struct format_commit_context *c)
993{
994 const char *ch = placeholder;
995 enum flush_type flush_type;
996 int to_column = 0;
997
998 switch (*ch++) {
999 case '<':
1000 flush_type = flush_right;
1001 break;
1002 case '>':
1003 if (*ch == '<') {
1004 flush_type = flush_both;
1005 ch++;
1640632b
NTND
1006 } else if (*ch == '>') {
1007 flush_type = flush_left_and_steal;
1008 ch++;
a5752342
NTND
1009 } else
1010 flush_type = flush_left;
1011 break;
1012 default:
1013 return 0;
1014 }
1015
1016 /* the next value means "wide enough to that column" */
1017 if (*ch == '|') {
1018 to_column = 1;
1019 ch++;
1020 }
1021
1022 if (*ch == '(') {
1023 const char *start = ch + 1;
a7f01c6b 1024 const char *end = start + strcspn(start, ",)");
a5752342
NTND
1025 char *next;
1026 int width;
1027 if (!end || end == start)
1028 return 0;
066790d7 1029 width = strtol(start, &next, 10);
a5752342
NTND
1030 if (next == start || width == 0)
1031 return 0;
066790d7
NTND
1032 if (width < 0) {
1033 if (to_column)
1034 width += term_columns();
1035 if (width < 0)
1036 return 0;
1037 }
a5752342
NTND
1038 c->padding = to_column ? -width : width;
1039 c->flush_type = flush_type;
a7f01c6b
NTND
1040
1041 if (*end == ',') {
1042 start = end + 1;
1043 end = strchr(start, ')');
1044 if (!end || end == start)
1045 return 0;
59556548 1046 if (starts_with(start, "trunc)"))
a7f01c6b 1047 c->truncate = trunc_right;
59556548 1048 else if (starts_with(start, "ltrunc)"))
a7f01c6b 1049 c->truncate = trunc_left;
59556548 1050 else if (starts_with(start, "mtrunc)"))
a7f01c6b
NTND
1051 c->truncate = trunc_middle;
1052 else
1053 return 0;
1054 } else
1055 c->truncate = trunc_none;
1056
a5752342
NTND
1057 return end - placeholder + 1;
1058 }
1059 return 0;
1060}
1061
4f732e0f
AW
1062static int match_placeholder_arg_value(const char *to_parse, const char *candidate,
1063 const char **end, const char **valuestart,
1064 size_t *valuelen)
84ff053d
TB
1065{
1066 const char *p;
1067
1068 if (!(skip_prefix(to_parse, candidate, &p)))
1069 return 0;
4f732e0f
AW
1070 if (valuestart) {
1071 if (*p == '=') {
1072 *valuestart = p + 1;
1073 *valuelen = strcspn(*valuestart, ",)");
1074 p = *valuestart + *valuelen;
1075 } else {
1076 if (*p != ',' && *p != ')')
1077 return 0;
1078 *valuestart = NULL;
1079 *valuelen = 0;
1080 }
1081 }
84ff053d
TB
1082 if (*p == ',') {
1083 *end = p + 1;
1084 return 1;
1085 }
1086 if (*p == ')') {
1087 *end = p;
1088 return 1;
1089 }
1090 return 0;
1091}
1092
4f732e0f
AW
1093static int match_placeholder_bool_arg(const char *to_parse, const char *candidate,
1094 const char **end, int *val)
1095{
1096 const char *argval;
1097 char *strval;
1098 size_t arglen;
1099 int v;
1100
1101 if (!match_placeholder_arg_value(to_parse, candidate, end, &argval, &arglen))
1102 return 0;
1103
1104 if (!argval) {
1105 *val = 1;
1106 return 1;
1107 }
1108
1109 strval = xstrndup(argval, arglen);
1110 v = git_parse_maybe_bool(strval);
1111 free(strval);
1112
1113 if (v == -1)
1114 return 0;
1115
1116 *val = v;
1117
1118 return 1;
1119}
1120
250bea0c
AW
1121static int format_trailer_match_cb(const struct strbuf *key, void *ud)
1122{
1123 const struct string_list *list = ud;
1124 const struct string_list_item *item;
1125
1126 for_each_string_list_item (item, list) {
1127 if (key->len == (uintptr_t)item->util &&
1128 !strncasecmp(item->string, key->buf, key->len))
1129 return 1;
1130 }
1131 return 0;
1132}
1133
7e77df39
NTND
1134static size_t format_commit_one(struct strbuf *sb, /* in UTF-8 */
1135 const char *placeholder,
9fa708da 1136 void *context)
f29d5958
RS
1137{
1138 struct format_commit_context *c = context;
1139 const struct commit *commit = c->commit;
177b29dc 1140 const char *msg = c->message;
f29d5958 1141 struct commit_list *p;
58311c66 1142 const char *arg;
fd2015b3 1143 size_t res;
ad6f028f 1144 char **slot;
93fc05eb 1145
93fc05eb 1146 /* these are independent of the commit */
fd2015b3
AW
1147 res = strbuf_expand_literal_cb(sb, placeholder, NULL);
1148 if (res)
1149 return res;
1150
cde75e59
RS
1151 switch (placeholder[0]) {
1152 case 'C':
59556548 1153 if (starts_with(placeholder + 1, "(auto)")) {
b15a3e00 1154 c->auto_color = want_color(c->pretty_ctx->color);
82b83da8 1155 if (c->auto_color && sb->len)
c99ad274 1156 strbuf_addstr(sb, GIT_COLOR_RESET);
a95f067e
NTND
1157 return 7; /* consumed 7 bytes, "C(auto)" */
1158 } else {
1159 int ret = parse_color(sb, placeholder, c);
1160 if (ret)
1161 c->auto_color = 0;
1162 /*
1163 * Otherwise, we decided to treat %C<unknown>
1164 * as a literal string, and the previous
1165 * %C(auto) is still valid.
1166 */
1167 return ret;
c002922a 1168 }
02edd56b
RS
1169 case 'w':
1170 if (placeholder[1] == '(') {
1171 unsigned long width = 0, indent1 = 0, indent2 = 0;
1172 char *next;
1173 const char *start = placeholder + 2;
1174 const char *end = strchr(start, ')');
1175 if (!end)
1176 return 0;
1177 if (end > start) {
1178 width = strtoul(start, &next, 10);
1179 if (*next == ',') {
1180 indent1 = strtoul(next + 1, &next, 10);
1181 if (*next == ',') {
1182 indent2 = strtoul(next + 1,
1183 &next, 10);
1184 }
1185 }
1186 if (*next != ')')
1187 return 0;
1188 }
1189 rewrap_message_tail(sb, c, width, indent1, indent2);
1190 return end - placeholder + 1;
1191 } else
1192 return 0;
a5752342
NTND
1193
1194 case '<':
1195 case '>':
9a1180fc 1196 return parse_padding_placeholder(placeholder, c);
cde75e59 1197 }
93fc05eb
JS
1198
1199 /* these depend on the commit */
1200 if (!commit->object.parsed)
109cd76d 1201 parse_object(the_repository, &commit->object.oid);
93fc05eb 1202
cde75e59
RS
1203 switch (placeholder[0]) {
1204 case 'H': /* commit hash */
a95f067e 1205 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_COMMIT));
f2fd0760 1206 strbuf_addstr(sb, oid_to_hex(&commit->object.oid));
a95f067e 1207 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
c3a670de 1208 return 1;
cde75e59 1209 case 'h': /* abbreviated commit hash */
a95f067e 1210 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_COMMIT));
30e677e0 1211 strbuf_add_unique_abbrev(sb, &commit->object.oid,
1eb47f16 1212 c->pretty_ctx->abbrev);
a95f067e 1213 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
c3a670de 1214 return 1;
cde75e59 1215 case 'T': /* tree hash */
2e27bd77 1216 strbuf_addstr(sb, oid_to_hex(get_commit_tree_oid(commit)));
c3a670de 1217 return 1;
cde75e59 1218 case 't': /* abbreviated tree hash */
2e27bd77 1219 strbuf_add_unique_abbrev(sb,
c89b6e13 1220 get_commit_tree_oid(commit),
1eb47f16 1221 c->pretty_ctx->abbrev);
c3a670de 1222 return 1;
cde75e59
RS
1223 case 'P': /* parent hashes */
1224 for (p = commit->parents; p; p = p->next) {
1225 if (p != commit->parents)
1226 strbuf_addch(sb, ' ');
f2fd0760 1227 strbuf_addstr(sb, oid_to_hex(&p->item->object.oid));
cde75e59 1228 }
c3a670de 1229 return 1;
cde75e59
RS
1230 case 'p': /* abbreviated parent hashes */
1231 for (p = commit->parents; p; p = p->next) {
1232 if (p != commit->parents)
1233 strbuf_addch(sb, ' ');
30e677e0 1234 strbuf_add_unique_abbrev(sb, &p->item->object.oid,
1eb47f16 1235 c->pretty_ctx->abbrev);
cde75e59 1236 }
c3a670de 1237 return 1;
cde75e59 1238 case 'm': /* left/right/bottom */
1df2d656 1239 strbuf_addstr(sb, get_revision_mark(NULL, commit));
c3a670de 1240 return 1;
3b3d443f 1241 case 'd':
a95f067e 1242 format_decorations(sb, commit, c->auto_color);
3b3d443f 1243 return 1;
9271095c 1244 case 'D':
9271095c
HJ
1245 format_decorations_extended(sb, commit, c->auto_color, "", ", ", "");
1246 return 1;
ad6f028f
IT
1247 case 'S': /* tag/branch like --source */
1248 if (!(c->pretty_ctx->rev && c->pretty_ctx->rev->sources))
1249 return 0;
1250 slot = revision_sources_at(c->pretty_ctx->rev->sources, commit);
1251 if (!(slot && *slot))
1252 return 0;
1253 strbuf_addstr(sb, *slot);
1254 return 1;
8f8f5476
TR
1255 case 'g': /* reflog info */
1256 switch(placeholder[1]) {
1257 case 'd': /* reflog selector */
1258 case 'D':
1259 if (c->pretty_ctx->reflog_info)
1260 get_reflog_selector(sb,
1261 c->pretty_ctx->reflog_info,
a5481a6c 1262 &c->pretty_ctx->date_mode,
55ccf85a 1263 c->pretty_ctx->date_mode_explicit,
8f8f5476
TR
1264 (placeholder[1] == 'd'));
1265 return 2;
1266 case 's': /* reflog message */
1267 if (c->pretty_ctx->reflog_info)
1268 get_reflog_message(sb, c->pretty_ctx->reflog_info);
1269 return 2;
cd1957f5
JK
1270 case 'n':
1271 case 'N':
1272 case 'e':
1273 case 'E':
1274 return format_reflog_person(sb,
1275 placeholder[1],
1276 c->pretty_ctx->reflog_info,
a5481a6c 1277 &c->pretty_ctx->date_mode);
8f8f5476
TR
1278 }
1279 return 0; /* unknown %g placeholder */
8b208f02 1280 case 'N':
ddf333f6
JH
1281 if (c->pretty_ctx->notes_message) {
1282 strbuf_addstr(sb, c->pretty_ctx->notes_message);
5b163603
JG
1283 return 1;
1284 }
1285 return 0;
cde75e59
RS
1286 }
1287
f6667c5e 1288 if (placeholder[0] == 'G') {
ffb6d7d5
SG
1289 if (!c->signature_check.result)
1290 check_commit_signature(c->commit, &(c->signature_check));
f6667c5e
JH
1291 switch (placeholder[1]) {
1292 case 'G':
ffb6d7d5
SG
1293 if (c->signature_check.gpg_output)
1294 strbuf_addstr(sb, c->signature_check.gpg_output);
f6667c5e
JH
1295 break;
1296 case '?':
ffb6d7d5 1297 switch (c->signature_check.result) {
f6667c5e
JH
1298 case 'G':
1299 case 'B':
661a1806 1300 case 'E':
e290c4b9
SG
1301 case 'U':
1302 case 'N':
661a1806
MG
1303 case 'X':
1304 case 'Y':
1305 case 'R':
ffb6d7d5 1306 strbuf_addch(sb, c->signature_check.result);
f6667c5e
JH
1307 }
1308 break;
1309 case 'S':
ffb6d7d5
SG
1310 if (c->signature_check.signer)
1311 strbuf_addstr(sb, c->signature_check.signer);
f6667c5e 1312 break;
0174eeaa 1313 case 'K':
ffb6d7d5
SG
1314 if (c->signature_check.key)
1315 strbuf_addstr(sb, c->signature_check.key);
0174eeaa 1316 break;
3daaaabe
MG
1317 case 'F':
1318 if (c->signature_check.fingerprint)
1319 strbuf_addstr(sb, c->signature_check.fingerprint);
1320 break;
4de9394d
MG
1321 case 'P':
1322 if (c->signature_check.primary_key_fingerprint)
1323 strbuf_addstr(sb, c->signature_check.primary_key_fingerprint);
1324 break;
aa4b78d4
JK
1325 default:
1326 return 0;
f6667c5e
JH
1327 }
1328 return 2;
1329 }
1330
1331
cde75e59 1332 /* For the rest we have to parse the commit header. */
f29d5958
RS
1333 if (!c->commit_header_parsed)
1334 parse_commit_header(c);
93fc05eb 1335
f29d5958 1336 switch (placeholder[0]) {
c3a670de
MC
1337 case 'a': /* author ... */
1338 return format_person_part(sb, placeholder[1],
d36f8679 1339 msg + c->author.off, c->author.len,
a5481a6c 1340 &c->pretty_ctx->date_mode);
c3a670de
MC
1341 case 'c': /* committer ... */
1342 return format_person_part(sb, placeholder[1],
d36f8679 1343 msg + c->committer.off, c->committer.len,
a5481a6c 1344 &c->pretty_ctx->date_mode);
c3a670de 1345 case 'e': /* encoding */
0940a76d
NTND
1346 if (c->commit_encoding)
1347 strbuf_addstr(sb, c->commit_encoding);
c3a670de 1348 return 1;
1367b12a
EB
1349 case 'B': /* raw body */
1350 /* message_off is always left at the initial newline */
1351 strbuf_addstr(sb, msg + c->message_off + 1);
1352 return 1;
f53bd743
RS
1353 }
1354
1355 /* Now we need to parse the commit message. */
1356 if (!c->commit_message_parsed)
1357 parse_commit_message(c);
1358
1359 switch (placeholder[0]) {
1360 case 's': /* subject */
1361 format_subject(sb, msg + c->subject_off, " ");
1362 return 1;
46d164b0
SB
1363 case 'f': /* sanitized subject */
1364 format_sanitized_subject(sb, msg + c->subject_off);
1365 return 1;
c3a670de 1366 case 'b': /* body */
f29d5958 1367 strbuf_addstr(sb, msg + c->body_off);
c3a670de 1368 return 1;
93fc05eb 1369 }
d9f31fbf 1370
58311c66 1371 if (skip_prefix(placeholder, "(trailers", &arg)) {
a388b10f 1372 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
250bea0c 1373 struct string_list filter_list = STRING_LIST_INIT_NODUP;
0b691d86 1374 struct strbuf sepbuf = STRBUF_INIT;
3e3f3478 1375 size_t ret = 0;
e5fba5d5
JK
1376
1377 opts.no_divider = 1;
1378
84ff053d
TB
1379 if (*arg == ':') {
1380 arg++;
1381 for (;;) {
250bea0c
AW
1382 const char *argval;
1383 size_t arglen;
1384
1385 if (match_placeholder_arg_value(arg, "key", &arg, &argval, &arglen)) {
1386 uintptr_t len = arglen;
1387
1388 if (!argval)
1389 goto trailer_out;
1390
1391 if (len && argval[len - 1] == ':')
1392 len--;
1393 string_list_append(&filter_list, argval)->util = (char *)len;
1394
1395 opts.filter = format_trailer_match_cb;
1396 opts.filter_data = &filter_list;
84ff053d 1397 opts.only_trailers = 1;
0b691d86
AW
1398 } else if (match_placeholder_arg_value(arg, "separator", &arg, &argval, &arglen)) {
1399 char *fmt;
1400
1401 strbuf_reset(&sepbuf);
1402 fmt = xstrndup(argval, arglen);
1403 strbuf_expand(&sepbuf, fmt, strbuf_expand_literal_cb, NULL);
1404 free(fmt);
1405 opts.separator = &sepbuf;
250bea0c 1406 } else if (!match_placeholder_bool_arg(arg, "only", &arg, &opts.only_trailers) &&
d9b936db
AW
1407 !match_placeholder_bool_arg(arg, "unfold", &arg, &opts.unfold) &&
1408 !match_placeholder_bool_arg(arg, "valueonly", &arg, &opts.value_only))
84ff053d
TB
1409 break;
1410 }
58311c66
JK
1411 }
1412 if (*arg == ')') {
1413 format_trailers_from_commit(sb, msg + c->subject_off, &opts);
3e3f3478 1414 ret = arg - placeholder + 1;
58311c66 1415 }
250bea0c
AW
1416 trailer_out:
1417 string_list_clear(&filter_list, 0);
0b691d86 1418 strbuf_release(&sepbuf);
3e3f3478 1419 return ret;
d9f31fbf
JK
1420 }
1421
c3a670de 1422 return 0; /* unknown placeholder */
cde75e59
RS
1423}
1424
a5752342
NTND
1425static size_t format_and_pad_commit(struct strbuf *sb, /* in UTF-8 */
1426 const char *placeholder,
1427 struct format_commit_context *c)
1428{
1429 struct strbuf local_sb = STRBUF_INIT;
1430 int total_consumed = 0, len, padding = c->padding;
1431 if (padding < 0) {
1432 const char *start = strrchr(sb->buf, '\n');
1433 int occupied;
1434 if (!start)
1435 start = sb->buf;
1436 occupied = utf8_strnwidth(start, -1, 1);
3ad87c80 1437 occupied += c->pretty_ctx->graph_width;
a5752342
NTND
1438 padding = (-padding) - occupied;
1439 }
1440 while (1) {
1441 int modifier = *placeholder == 'C';
1442 int consumed = format_commit_one(&local_sb, placeholder, c);
1443 total_consumed += consumed;
1444
1445 if (!modifier)
1446 break;
1447
1448 placeholder += consumed;
1449 if (*placeholder != '%')
1450 break;
1451 placeholder++;
1452 total_consumed++;
1453 }
1454 len = utf8_strnwidth(local_sb.buf, -1, 1);
1640632b
NTND
1455
1456 if (c->flush_type == flush_left_and_steal) {
1457 const char *ch = sb->buf + sb->len - 1;
1458 while (len > padding && ch > sb->buf) {
1459 const char *p;
1460 if (*ch == ' ') {
1461 ch--;
1462 padding++;
1463 continue;
1464 }
1465 /* check for trailing ansi sequences */
1466 if (*ch != 'm')
1467 break;
1468 p = ch - 1;
1469 while (ch - p < 10 && *p != '\033')
1470 p--;
1471 if (*p != '\033' ||
1472 ch + 1 - p != display_mode_esc_sequence_len(p))
1473 break;
1474 /*
1475 * got a good ansi sequence, put it back to
1476 * local_sb as we're cutting sb
1477 */
1478 strbuf_insert(&local_sb, 0, p, ch + 1 - p);
1479 ch = p - 1;
1480 }
1481 strbuf_setlen(sb, ch + 1 - sb->buf);
1482 c->flush_type = flush_left;
1483 }
1484
a7f01c6b
NTND
1485 if (len > padding) {
1486 switch (c->truncate) {
1487 case trunc_left:
1488 strbuf_utf8_replace(&local_sb,
1489 0, len - (padding - 2),
1490 "..");
1491 break;
1492 case trunc_middle:
1493 strbuf_utf8_replace(&local_sb,
1494 padding / 2 - 1,
1495 len - (padding - 2),
1496 "..");
1497 break;
1498 case trunc_right:
1499 strbuf_utf8_replace(&local_sb,
1500 padding - 2, len - (padding - 2),
1501 "..");
1502 break;
1503 case trunc_none:
1504 break;
1505 }
e992d1eb 1506 strbuf_addbuf(sb, &local_sb);
a7f01c6b 1507 } else {
a5752342
NTND
1508 int sb_len = sb->len, offset = 0;
1509 if (c->flush_type == flush_left)
1510 offset = padding - len;
1511 else if (c->flush_type == flush_both)
1512 offset = (padding - len) / 2;
1513 /*
1514 * we calculate padding in columns, now
1515 * convert it back to chars
1516 */
1517 padding = padding - len + local_sb.len;
415792ed 1518 strbuf_addchars(sb, ' ', padding);
a5752342
NTND
1519 memcpy(sb->buf + sb_len + offset, local_sb.buf,
1520 local_sb.len);
1521 }
1522 strbuf_release(&local_sb);
1523 c->flush_type = no_flush;
1524 return total_consumed;
1525}
1526
7e77df39
NTND
1527static size_t format_commit_item(struct strbuf *sb, /* in UTF-8 */
1528 const char *placeholder,
9fa708da
JH
1529 void *context)
1530{
1531 int consumed;
1532 size_t orig_len;
1533 enum {
1534 NO_MAGIC,
1535 ADD_LF_BEFORE_NON_EMPTY,
1536 DEL_LF_BEFORE_EMPTY,
223a923c 1537 ADD_SP_BEFORE_NON_EMPTY
9fa708da
JH
1538 } magic = NO_MAGIC;
1539
1540 switch (placeholder[0]) {
1541 case '-':
1542 magic = DEL_LF_BEFORE_EMPTY;
1543 break;
1544 case '+':
1545 magic = ADD_LF_BEFORE_NON_EMPTY;
1546 break;
7b88176e
MG
1547 case ' ':
1548 magic = ADD_SP_BEFORE_NON_EMPTY;
1549 break;
9fa708da
JH
1550 default:
1551 break;
1552 }
1553 if (magic != NO_MAGIC)
1554 placeholder++;
1555
1556 orig_len = sb->len;
a5752342
NTND
1557 if (((struct format_commit_context *)context)->flush_type != no_flush)
1558 consumed = format_and_pad_commit(sb, placeholder, context);
1559 else
1560 consumed = format_commit_one(sb, placeholder, context);
9fa708da
JH
1561 if (magic == NO_MAGIC)
1562 return consumed;
1563
1564 if ((orig_len == sb->len) && magic == DEL_LF_BEFORE_EMPTY) {
1565 while (sb->len && sb->buf[sb->len - 1] == '\n')
1566 strbuf_setlen(sb, sb->len - 1);
7b88176e
MG
1567 } else if (orig_len != sb->len) {
1568 if (magic == ADD_LF_BEFORE_NON_EMPTY)
1569 strbuf_insert(sb, orig_len, "\n", 1);
1570 else if (magic == ADD_SP_BEFORE_NON_EMPTY)
1571 strbuf_insert(sb, orig_len, " ", 1);
9fa708da
JH
1572 }
1573 return consumed + 1;
1574}
1575
5b163603
JG
1576static size_t userformat_want_item(struct strbuf *sb, const char *placeholder,
1577 void *context)
1578{
1579 struct userformat_want *w = context;
1580
7b88176e 1581 if (*placeholder == '+' || *placeholder == '-' || *placeholder == ' ')
5b163603
JG
1582 placeholder++;
1583
1584 switch (*placeholder) {
1585 case 'N':
1586 w->notes = 1;
1587 break;
ad6f028f
IT
1588 case 'S':
1589 w->source = 1;
1590 break;
5b163603
JG
1591 }
1592 return 0;
1593}
1594
1595void userformat_find_requirements(const char *fmt, struct userformat_want *w)
1596{
1597 struct strbuf dummy = STRBUF_INIT;
1598
1599 if (!fmt) {
1600 if (!user_format)
1601 return;
1602 fmt = user_format;
1603 }
a6253d10 1604 strbuf_expand(&dummy, fmt, userformat_want_item, w);
5b163603
JG
1605 strbuf_release(&dummy);
1606}
1607
f54fbf5e
SB
1608void repo_format_commit_message(struct repository *r,
1609 const struct commit *commit,
1610 const char *format, struct strbuf *sb,
1611 const struct pretty_print_context *pretty_ctx)
cde75e59 1612{
f29d5958 1613 struct format_commit_context context;
177b29dc 1614 const char *output_enc = pretty_ctx->output_encoding;
7e77df39 1615 const char *utf8 = "UTF-8";
f29d5958
RS
1616
1617 memset(&context, 0, sizeof(context));
1618 context.commit = commit;
dd2e794a 1619 context.pretty_ctx = pretty_ctx;
02edd56b 1620 context.wrap_start = sb->len;
7d509878
AS
1621 /*
1622 * convert a commit message to UTF-8 first
1623 * as far as 'format_commit_item' assumes it in UTF-8
1624 */
f54fbf5e
SB
1625 context.message = repo_logmsg_reencode(r, commit,
1626 &context.commit_encoding,
1627 utf8);
177b29dc 1628
c3a670de 1629 strbuf_expand(sb, format, format_commit_item, &context);
02edd56b 1630 rewrap_message_tail(sb, &context, 0, 0, 0);
177b29dc 1631
7d509878 1632 /* then convert a commit message to an actual output encoding */
7e77df39
NTND
1633 if (output_enc) {
1634 if (same_encoding(utf8, output_enc))
1635 output_enc = NULL;
1636 } else {
1637 if (context.commit_encoding &&
1638 !same_encoding(context.commit_encoding, utf8))
1639 output_enc = context.commit_encoding;
1640 }
1641
1642 if (output_enc) {
c7d017d7 1643 size_t outsz;
7e77df39
NTND
1644 char *out = reencode_string_len(sb->buf, sb->len,
1645 output_enc, utf8, &outsz);
1646 if (out)
1647 strbuf_attach(sb, out, outsz, outsz + 1);
1648 }
1649
0940a76d 1650 free(context.commit_encoding);
f54fbf5e 1651 repo_unuse_commit_buffer(r, commit, context.message);
93fc05eb
JS
1652}
1653
10f2fbff 1654static void pp_header(struct pretty_print_context *pp,
93fc05eb
JS
1655 const char *encoding,
1656 const struct commit *commit,
1657 const char **msg_p,
1658 struct strbuf *sb)
1659{
1660 int parents_shown = 0;
1661
1662 for (;;) {
e3f1da98 1663 const char *name, *line = *msg_p;
93fc05eb
JS
1664 int linelen = get_one_line(*msg_p);
1665
1666 if (!linelen)
1667 return;
1668 *msg_p += linelen;
1669
1670 if (linelen == 1)
1671 /* End of header */
1672 return;
1673
6bf13944 1674 if (pp->fmt == CMIT_FMT_RAW) {
93fc05eb
JS
1675 strbuf_add(sb, line, linelen);
1676 continue;
1677 }
1678
59556548 1679 if (starts_with(line, "parent ")) {
580f0980 1680 if (linelen != the_hash_algo->hexsz + 8)
93fc05eb
JS
1681 die("bad parent line in commit");
1682 continue;
1683 }
1684
1685 if (!parents_shown) {
4bbaa1eb 1686 unsigned num = commit_list_count(commit->parents);
93fc05eb 1687 /* with enough slop */
580f0980 1688 strbuf_grow(sb, num * (GIT_MAX_HEXSZ + 10) + 20);
6bf13944 1689 add_merge_info(pp, sb, commit);
93fc05eb
JS
1690 parents_shown = 1;
1691 }
1692
1693 /*
1694 * MEDIUM == DEFAULT shows only author with dates.
1695 * FULL shows both authors but not dates.
1696 * FULLER shows both authors and dates.
1697 */
e3f1da98 1698 if (skip_prefix(line, "author ", &name)) {
93fc05eb 1699 strbuf_grow(sb, linelen + 80);
e3f1da98 1700 pp_user_info(pp, "Author", sb, name, encoding);
93fc05eb 1701 }
e3f1da98 1702 if (skip_prefix(line, "committer ", &name) &&
6bf13944 1703 (pp->fmt == CMIT_FMT_FULL || pp->fmt == CMIT_FMT_FULLER)) {
93fc05eb 1704 strbuf_grow(sb, linelen + 80);
e3f1da98 1705 pp_user_info(pp, "Commit", sb, name, encoding);
93fc05eb
JS
1706 }
1707 }
1708}
1709
10f2fbff 1710void pp_title_line(struct pretty_print_context *pp,
b02bd65f
DB
1711 const char **msg_p,
1712 struct strbuf *sb,
b02bd65f 1713 const char *encoding,
267123b4 1714 int need_8bit_cte)
93fc05eb 1715{
41dd00ba 1716 static const int max_length = 78; /* per rfc2047 */
93fc05eb
JS
1717 struct strbuf title;
1718
1719 strbuf_init(&title, 80);
9553d2b2
JK
1720 *msg_p = format_subject(&title, *msg_p,
1721 pp->preserve_subject ? "\n" : " ");
93fc05eb
JS
1722
1723 strbuf_grow(sb, title.len + 1024);
6d167fd7
RS
1724 if (pp->print_email_subject) {
1725 if (pp->rev)
1726 fmt_output_email_subject(sb, pp->rev);
da55ff3d 1727 if (needs_rfc2047_encoding(title.buf, title.len))
41dd00ba
JS
1728 add_rfc2047(sb, title.buf, title.len,
1729 encoding, RFC2047_SUBJECT);
1730 else
1731 strbuf_add_wrapped_bytes(sb, title.buf, title.len,
1732 -last_line_length(sb), 1, max_length);
93fc05eb
JS
1733 } else {
1734 strbuf_addbuf(sb, &title);
1735 }
1736 strbuf_addch(sb, '\n');
1737
a9080475
JK
1738 if (need_8bit_cte == 0) {
1739 int i;
1740 for (i = 0; i < pp->in_body_headers.nr; i++) {
1741 if (has_non_ascii(pp->in_body_headers.items[i].string)) {
1742 need_8bit_cte = 1;
1743 break;
1744 }
1745 }
1746 }
1747
6bf4f1b4 1748 if (need_8bit_cte > 0) {
93fc05eb
JS
1749 const char *header_fmt =
1750 "MIME-Version: 1.0\n"
1751 "Content-Type: text/plain; charset=%s\n"
1752 "Content-Transfer-Encoding: 8bit\n";
1753 strbuf_addf(sb, header_fmt, encoding);
1754 }
6bf13944
JK
1755 if (pp->after_subject) {
1756 strbuf_addstr(sb, pp->after_subject);
93fc05eb 1757 }
9f23e040 1758 if (cmit_fmt_is_mail(pp->fmt)) {
93fc05eb
JS
1759 strbuf_addch(sb, '\n');
1760 }
a9080475
JK
1761
1762 if (pp->in_body_headers.nr) {
1763 int i;
1764 for (i = 0; i < pp->in_body_headers.nr; i++) {
1765 strbuf_addstr(sb, pp->in_body_headers.items[i].string);
1766 free(pp->in_body_headers.items[i].string);
1767 }
1768 string_list_clear(&pp->in_body_headers, 0);
1769 strbuf_addch(sb, '\n');
1770 }
1771
93fc05eb
JS
1772 strbuf_release(&title);
1773}
1774
7cc13c71
LT
1775static int pp_utf8_width(const char *start, const char *end)
1776{
1777 int width = 0;
1778 size_t remain = end - start;
1779
1780 while (remain) {
1781 int n = utf8_width(&start, &remain);
1782 if (n < 0 || !start)
1783 return -1;
1784 width += n;
1785 }
1786 return width;
1787}
1788
fe37a9c5 1789static void strbuf_add_tabexpand(struct strbuf *sb, int tabwidth,
7cc13c71
LT
1790 const char *line, int linelen)
1791{
1792 const char *tab;
1793
1794 while ((tab = memchr(line, '\t', linelen)) != NULL) {
1795 int width = pp_utf8_width(line, tab);
1796
1797 /*
1798 * If it wasn't well-formed utf8, or it
1799 * had characters with badly defined
1800 * width (control characters etc), just
1801 * give up on trying to align things.
1802 */
1803 if (width < 0)
1804 break;
1805
1806 /* Output the data .. */
1807 strbuf_add(sb, line, tab - line);
1808
1809 /* .. and the de-tabified tab */
fe37a9c5 1810 strbuf_addchars(sb, ' ', tabwidth - (width % tabwidth));
7cc13c71
LT
1811
1812 /* Skip over the printed part .. */
1813 linelen -= tab + 1 - line;
1814 line = tab + 1;
1815 }
1816
1817 /*
1818 * Print out everything after the last tab without
1819 * worrying about width - there's nothing more to
1820 * align.
1821 */
1822 strbuf_add(sb, line, linelen);
1823}
1824
1825/*
1826 * pp_handle_indent() prints out the intendation, and
1827 * the whole line (without the final newline), after
1828 * de-tabifying.
1829 */
1830static void pp_handle_indent(struct pretty_print_context *pp,
1831 struct strbuf *sb, int indent,
1832 const char *line, int linelen)
1833{
1834 strbuf_addchars(sb, ' ', indent);
1835 if (pp->expand_tabs_in_log)
fe37a9c5 1836 strbuf_add_tabexpand(sb, pp->expand_tabs_in_log, line, linelen);
7cc13c71
LT
1837 else
1838 strbuf_add(sb, line, linelen);
1839}
1840
9f23e040
EW
1841static int is_mboxrd_from(const char *line, int len)
1842{
1843 /*
1844 * a line matching /^From $/ here would only have len == 4
1845 * at this point because is_empty_line would've trimmed all
1846 * trailing space
1847 */
1848 return len > 4 && starts_with(line + strspn(line, ">"), "From ");
1849}
1850
10f2fbff 1851void pp_remainder(struct pretty_print_context *pp,
b02bd65f
DB
1852 const char **msg_p,
1853 struct strbuf *sb,
1854 int indent)
93fc05eb
JS
1855{
1856 int first = 1;
1857 for (;;) {
1858 const char *line = *msg_p;
1859 int linelen = get_one_line(line);
1860 *msg_p += linelen;
1861
1862 if (!linelen)
1863 break;
1864
77356122 1865 if (is_blank_line(line, &linelen)) {
93fc05eb
JS
1866 if (first)
1867 continue;
6bf13944 1868 if (pp->fmt == CMIT_FMT_SHORT)
93fc05eb
JS
1869 break;
1870 }
1871 first = 0;
1872
1873 strbuf_grow(sb, linelen + indent + 20);
415792ed 1874 if (indent)
7cc13c71 1875 pp_handle_indent(pp, sb, indent, line, linelen);
0893eec8 1876 else if (pp->expand_tabs_in_log)
fe37a9c5
JH
1877 strbuf_add_tabexpand(sb, pp->expand_tabs_in_log,
1878 line, linelen);
9f23e040
EW
1879 else {
1880 if (pp->fmt == CMIT_FMT_MBOXRD &&
1881 is_mboxrd_from(line, linelen))
1882 strbuf_addch(sb, '>');
1883
7cc13c71 1884 strbuf_add(sb, line, linelen);
9f23e040 1885 }
93fc05eb
JS
1886 strbuf_addch(sb, '\n');
1887 }
1888}
1889
10f2fbff 1890void pretty_print_commit(struct pretty_print_context *pp,
6bf13944
JK
1891 const struct commit *commit,
1892 struct strbuf *sb)
93fc05eb
JS
1893{
1894 unsigned long beginning_of_body;
1895 int indent = 4;
dd0d388c 1896 const char *msg;
b000c59b 1897 const char *reencoded;
93fc05eb 1898 const char *encoding;
6bf13944 1899 int need_8bit_cte = pp->need_8bit_cte;
93fc05eb 1900
6bf13944
JK
1901 if (pp->fmt == CMIT_FMT_USERFORMAT) {
1902 format_commit_message(commit, user_format, sb, pp);
93fc05eb
JS
1903 return;
1904 }
1905
e297cf5a 1906 encoding = get_log_output_encoding();
5a10d236 1907 msg = reencoded = logmsg_reencode(commit, NULL, encoding);
93fc05eb 1908
9f23e040 1909 if (pp->fmt == CMIT_FMT_ONELINE || cmit_fmt_is_mail(pp->fmt))
93fc05eb
JS
1910 indent = 0;
1911
6bf4f1b4
JH
1912 /*
1913 * We need to check and emit Content-type: to mark it
1914 * as 8-bit if we haven't done so.
93fc05eb 1915 */
9f23e040 1916 if (cmit_fmt_is_mail(pp->fmt) && need_8bit_cte == 0) {
93fc05eb
JS
1917 int i, ch, in_body;
1918
1919 for (in_body = i = 0; (ch = msg[i]); i++) {
1920 if (!in_body) {
1921 /* author could be non 7-bit ASCII but
1922 * the log may be so; skip over the
1923 * header part first.
1924 */
1925 if (ch == '\n' && msg[i+1] == '\n')
1926 in_body = 1;
1927 }
1928 else if (non_ascii(ch)) {
6bf4f1b4 1929 need_8bit_cte = 1;
93fc05eb
JS
1930 break;
1931 }
1932 }
1933 }
1934
6bf13944 1935 pp_header(pp, encoding, commit, &msg, sb);
6d167fd7 1936 if (pp->fmt != CMIT_FMT_ONELINE && !pp->print_email_subject) {
93fc05eb
JS
1937 strbuf_addch(sb, '\n');
1938 }
1939
1940 /* Skip excess blank lines at the beginning of body, if any... */
77356122 1941 msg = skip_blank_lines(msg);
93fc05eb
JS
1942
1943 /* These formats treat the title line specially. */
9f23e040 1944 if (pp->fmt == CMIT_FMT_ONELINE || cmit_fmt_is_mail(pp->fmt))
6bf13944 1945 pp_title_line(pp, &msg, sb, encoding, need_8bit_cte);
93fc05eb
JS
1946
1947 beginning_of_body = sb->len;
6bf13944
JK
1948 if (pp->fmt != CMIT_FMT_ONELINE)
1949 pp_remainder(pp, &msg, sb, indent);
93fc05eb
JS
1950 strbuf_rtrim(sb);
1951
1952 /* Make sure there is an EOLN for the non-oneline case */
6bf13944 1953 if (pp->fmt != CMIT_FMT_ONELINE)
93fc05eb
JS
1954 strbuf_addch(sb, '\n');
1955
1956 /*
1957 * The caller may append additional body text in e-mail
1958 * format. Make sure we did not strip the blank line
1959 * between the header and the body.
1960 */
9f23e040 1961 if (cmit_fmt_is_mail(pp->fmt) && sb->len <= beginning_of_body)
93fc05eb 1962 strbuf_addch(sb, '\n');
a97a7468 1963
b66103c3 1964 unuse_commit_buffer(commit, reencoded);
93fc05eb 1965}
8b8a5374
JK
1966
1967void pp_commit_easy(enum cmit_fmt fmt, const struct commit *commit,
1968 struct strbuf *sb)
1969{
1970 struct pretty_print_context pp = {0};
6bf13944
JK
1971 pp.fmt = fmt;
1972 pretty_print_commit(&pp, commit, sb);
8b8a5374 1973}