git

1
#define USE_THE_REPOSITORY_VARIABLE
2

3
#include "git-compat-util.h"
4
#include "config.h"
5
#include "commit.h"
6
#include "environment.h"
7
#include "gettext.h"
8
#include "hash.h"
9
#include "hex.h"
10
#include "utf8.h"
11
#include "diff.h"
12
#include "pager.h"
13
#include "revision.h"
14
#include "string-list.h"
15
#include "mailmap.h"
16
#include "log-tree.h"
17
#include "notes.h"
18
#include "color.h"
19
#include "reflog-walk.h"
20
#include "gpg-interface.h"
21
#include "trailer.h"
22
#include "run-command.h"
23
#include "object-name.h"
24

25
/*
26
 * The limit for formatting directives, which enable the caller to append
27
 * arbitrarily many bytes to the formatted buffer. This includes padding
28
 * and wrapping formatters.
29
 */
30
#define FORMATTING_LIMIT (16 * 1024)
31

32
static char *user_format;
33
static struct cmt_fmt_map {
34
	const char *name;
35
	enum cmit_fmt format;
36
	int is_tformat;
37
	int expand_tabs_in_log;
38
	int is_alias;
39
	enum date_mode_type default_date_mode_type;
40
	const char *user_format;
41
} *commit_formats;
42
static size_t builtin_formats_len;
43
static size_t commit_formats_len;
44
static size_t commit_formats_alloc;
45
static struct cmt_fmt_map *find_commit_format(const char *sought);
46

47
int commit_format_is_empty(enum cmit_fmt fmt)
48
{
49
	return fmt == CMIT_FMT_USERFORMAT && !*user_format;
50
}
51

52
static void save_user_format(struct rev_info *rev, const char *cp, int is_tformat)
53
{
54
	free(user_format);
55
	user_format = xstrdup(cp);
56
	if (is_tformat)
57
		rev->use_terminator = 1;
58
	rev->commit_format = CMIT_FMT_USERFORMAT;
59
}
60

61
static int git_pretty_formats_config(const char *var, const char *value,
62
				     const struct config_context *ctx UNUSED,
63
				     void *cb UNUSED)
64
{
65
	struct cmt_fmt_map *commit_format = NULL;
66
	const char *name;
67
	char *fmt;
68
	int i;
69

70
	if (!skip_prefix(var, "pretty.", &name))
71
		return 0;
72

73
	for (i = 0; i < builtin_formats_len; i++) {
74
		if (!strcmp(commit_formats[i].name, name))
75
			return 0;
76
	}
77

78
	for (i = builtin_formats_len; i < commit_formats_len; i++) {
79
		if (!strcmp(commit_formats[i].name, name)) {
80
			commit_format = &commit_formats[i];
81
			break;
82
		}
83
	}
84

85
	if (!commit_format) {
86
		ALLOC_GROW(commit_formats, commit_formats_len+1,
87
			   commit_formats_alloc);
88
		commit_format = &commit_formats[commit_formats_len];
89
		memset(commit_format, 0, sizeof(*commit_format));
90
		commit_formats_len++;
91
	}
92

93
	commit_format->name = xstrdup(name);
94
	commit_format->format = CMIT_FMT_USERFORMAT;
95
	if (git_config_string(&fmt, var, value))
96
		return -1;
97

98
	if (skip_prefix(fmt, "format:", &commit_format->user_format)) {
99
		commit_format->is_tformat = 0;
100
	} else if (skip_prefix(fmt, "tformat:", &commit_format->user_format)) {
101
		commit_format->is_tformat = 1;
102
	} else if (strchr(fmt, '%')) {
103
		commit_format->is_tformat = 1;
104
		commit_format->user_format = fmt;
105
	} else {
106
		commit_format->is_alias = 1;
107
		commit_format->user_format = fmt;
108
	}
109

110
	return 0;
111
}
112

113
static void setup_commit_formats(void)
114
{
115
	struct cmt_fmt_map builtin_formats[] = {
116
		{ "raw",	CMIT_FMT_RAW,		0,	0 },
117
		{ "medium",	CMIT_FMT_MEDIUM,	0,	8 },
118
		{ "short",	CMIT_FMT_SHORT,		0,	0 },
119
		{ "email",	CMIT_FMT_EMAIL,		0,	0 },
120
		{ "mboxrd",	CMIT_FMT_MBOXRD,	0,	0 },
121
		{ "fuller",	CMIT_FMT_FULLER,	0,	8 },
122
		{ "full",	CMIT_FMT_FULL,		0,	8 },
123
		{ "oneline",	CMIT_FMT_ONELINE,	1,	0 },
124
		{ "reference",	CMIT_FMT_USERFORMAT,	1,	0,
125
			0, DATE_SHORT, "%C(auto)%h (%s, %ad)" },
126
		/*
127
		 * Please update $__git_log_pretty_formats in
128
		 * git-completion.bash when you add new formats.
129
		 */
130
	};
131
	commit_formats_len = ARRAY_SIZE(builtin_formats);
132
	builtin_formats_len = commit_formats_len;
133
	ALLOC_GROW(commit_formats, commit_formats_len, commit_formats_alloc);
134
	COPY_ARRAY(commit_formats, builtin_formats,
135
		   ARRAY_SIZE(builtin_formats));
136

137
	git_config(git_pretty_formats_config, NULL);
138
}
139

140
static struct cmt_fmt_map *find_commit_format_recursive(const char *sought,
141
							const char *original,
142
							int num_redirections)
143
{
144
	struct cmt_fmt_map *found = NULL;
145
	size_t found_match_len = 0;
146
	int i;
147

148
	if (num_redirections >= commit_formats_len)
149
		die("invalid --pretty format: "
150
		    "'%s' references an alias which points to itself",
151
		    original);
152

153
	for (i = 0; i < commit_formats_len; i++) {
154
		size_t match_len;
155

156
		if (!istarts_with(commit_formats[i].name, sought))
157
			continue;
158

159
		match_len = strlen(commit_formats[i].name);
160
		if (found == NULL || found_match_len > match_len) {
161
			found = &commit_formats[i];
162
			found_match_len = match_len;
163
		}
164
	}
165

166
	if (found && found->is_alias) {
167
		found = find_commit_format_recursive(found->user_format,
168
						     original,
169
						     num_redirections+1);
170
	}
171

172
	return found;
173
}
174

175
static struct cmt_fmt_map *find_commit_format(const char *sought)
176
{
177
	if (!commit_formats)
178
		setup_commit_formats();
179

180
	return find_commit_format_recursive(sought, sought, 0);
181
}
182

183
void get_commit_format(const char *arg, struct rev_info *rev)
184
{
185
	struct cmt_fmt_map *commit_format;
186

187
	rev->use_terminator = 0;
188
	if (!arg) {
189
		rev->commit_format = CMIT_FMT_DEFAULT;
190
		return;
191
	}
192
	if (skip_prefix(arg, "format:", &arg)) {
193
		save_user_format(rev, arg, 0);
194
		return;
195
	}
196

197
	if (!*arg || skip_prefix(arg, "tformat:", &arg) || strchr(arg, '%')) {
198
		save_user_format(rev, arg, 1);
199
		return;
200
	}
201

202
	commit_format = find_commit_format(arg);
203
	if (!commit_format)
204
		die("invalid --pretty format: %s", arg);
205

206
	rev->commit_format = commit_format->format;
207
	rev->use_terminator = commit_format->is_tformat;
208
	rev->expand_tabs_in_log_default = commit_format->expand_tabs_in_log;
209
	if (!rev->date_mode_explicit && commit_format->default_date_mode_type)
210
		rev->date_mode.type = commit_format->default_date_mode_type;
211
	if (commit_format->format == CMIT_FMT_USERFORMAT) {
212
		save_user_format(rev, commit_format->user_format,
213
				 commit_format->is_tformat);
214
	}
215
}
216

217
/*
218
 * Generic support for pretty-printing the header
219
 */
220
static int get_one_line(const char *msg)
221
{
222
	int ret = 0;
223

224
	for (;;) {
225
		char c = *msg++;
226
		if (!c)
227
			break;
228
		ret++;
229
		if (c == '\n')
230
			break;
231
	}
232
	return ret;
233
}
234

235
/* High bit set, or ISO-2022-INT */
236
static int non_ascii(int ch)
237
{
238
	return !isascii(ch) || ch == '\033';
239
}
240

241
int has_non_ascii(const char *s)
242
{
243
	int ch;
244
	if (!s)
245
		return 0;
246
	while ((ch = *s++) != '\0') {
247
		if (non_ascii(ch))
248
			return 1;
249
	}
250
	return 0;
251
}
252

253
static int is_rfc822_special(char ch)
254
{
255
	switch (ch) {
256
	case '(':
257
	case ')':
258
	case '<':
259
	case '>':
260
	case '[':
261
	case ']':
262
	case ':':
263
	case ';':
264
	case '@':
265
	case ',':
266
	case '.':
267
	case '"':
268
	case '\\':
269
		return 1;
270
	default:
271
		return 0;
272
	}
273
}
274

275
static int needs_rfc822_quoting(const char *s, int len)
276
{
277
	int i;
278
	for (i = 0; i < len; i++)
279
		if (is_rfc822_special(s[i]))
280
			return 1;
281
	return 0;
282
}
283

284
static int last_line_length(struct strbuf *sb)
285
{
286
	int i;
287

288
	/* How many bytes are already used on the last line? */
289
	for (i = sb->len - 1; i >= 0; i--)
290
		if (sb->buf[i] == '\n')
291
			break;
292
	return sb->len - (i + 1);
293
}
294

295
static void add_rfc822_quoted(struct strbuf *out, const char *s, int len)
296
{
297
	int i;
298

299
	/* just a guess, we may have to also backslash-quote */
300
	strbuf_grow(out, len + 2);
301

302
	strbuf_addch(out, '"');
303
	for (i = 0; i < len; i++) {
304
		switch (s[i]) {
305
		case '"':
306
		case '\\':
307
			strbuf_addch(out, '\\');
308
			/* fall through */
309
		default:
310
			strbuf_addch(out, s[i]);
311
		}
312
	}
313
	strbuf_addch(out, '"');
314
}
315

316
enum rfc2047_type {
317
	RFC2047_SUBJECT,
318
	RFC2047_ADDRESS
319
};
320

321
static int is_rfc2047_special(char ch, enum rfc2047_type type)
322
{
323
	/*
324
	 * rfc2047, section 4.2:
325
	 *
326
	 *    8-bit values which correspond to printable ASCII characters other
327
	 *    than "=", "?", and "_" (underscore), MAY be represented as those
328
	 *    characters.  (But see section 5 for restrictions.)  In
329
	 *    particular, SPACE and TAB MUST NOT be represented as themselves
330
	 *    within encoded words.
331
	 */
332

333
	/*
334
	 * rule out non-ASCII characters and non-printable characters (the
335
	 * non-ASCII check should be redundant as isprint() is not localized
336
	 * and only knows about ASCII, but be defensive about that)
337
	 */
338
	if (non_ascii(ch) || !isprint(ch))
339
		return 1;
340

341
	/*
342
	 * rule out special printable characters (' ' should be the only
343
	 * whitespace character considered printable, but be defensive and use
344
	 * isspace())
345
	 */
346
	if (isspace(ch) || ch == '=' || ch == '?' || ch == '_')
347
		return 1;
348

349
	/*
350
	 * rfc2047, section 5.3:
351
	 *
352
	 *    As a replacement for a 'word' entity within a 'phrase', for example,
353
	 *    one that precedes an address in a From, To, or Cc header.  The ABNF
354
	 *    definition for 'phrase' from RFC 822 thus becomes:
355
	 *
356
	 *    phrase = 1*( encoded-word / word )
357
	 *
358
	 *    In this case the set of characters that may be used in a "Q"-encoded
359
	 *    'encoded-word' is restricted to: <upper and lower case ASCII
360
	 *    letters, decimal digits, "!", "*", "+", "-", "/", "=", and "_"
361
	 *    (underscore, ASCII 95.)>.  An 'encoded-word' that appears within a
362
	 *    'phrase' MUST be separated from any adjacent 'word', 'text' or
363
	 *    'special' by 'linear-white-space'.
364
	 */
365

366
	if (type != RFC2047_ADDRESS)
367
		return 0;
368

369
	/* '=' and '_' are special cases and have been checked above */
370
	return !(isalnum(ch) || ch == '!' || ch == '*' || ch == '+' || ch == '-' || ch == '/');
371
}
372

373
static int needs_rfc2047_encoding(const char *line, int len)
374
{
375
	int i;
376

377
	for (i = 0; i < len; i++) {
378
		int ch = line[i];
379
		if (non_ascii(ch) || ch == '\n')
380
			return 1;
381
		if ((i + 1 < len) && (ch == '=' && line[i+1] == '?'))
382
			return 1;
383
	}
384

385
	return 0;
386
}
387

388
static void add_rfc2047(struct strbuf *sb, const char *line, size_t len,
389
		       const char *encoding, enum rfc2047_type type)
390
{
391
	static const int max_encoded_length = 76; /* per rfc2047 */
392
	int i;
393
	int line_len = last_line_length(sb);
394

395
	strbuf_grow(sb, len * 3 + strlen(encoding) + 100);
396
	strbuf_addf(sb, "=?%s?q?", encoding);
397
	line_len += strlen(encoding) + 5; /* 5 for =??q? */
398

399
	while (len) {
400
		/*
401
		 * RFC 2047, section 5 (3):
402
		 *
403
		 * Each 'encoded-word' MUST represent an integral number of
404
		 * characters.  A multi-octet character may not be split across
405
		 * adjacent 'encoded- word's.
406
		 */
407
		const unsigned char *p = (const unsigned char *)line;
408
		int chrlen = mbs_chrlen(&line, &len, encoding);
409
		int is_special = (chrlen > 1) || is_rfc2047_special(*p, type);
410

411
		/* "=%02X" * chrlen, or the byte itself */
412
		const char *encoded_fmt = is_special ? "=%02X"    : "%c";
413
		int	    encoded_len = is_special ? 3 * chrlen : 1;
414

415
		/*
416
		 * According to RFC 2047, we could encode the special character
417
		 * ' ' (space) with '_' (underscore) for readability. But many
418
		 * programs do not understand this and just leave the
419
		 * underscore in place. Thus, we do nothing special here, which
420
		 * causes ' ' to be encoded as '=20', avoiding this problem.
421
		 */
422

423
		if (line_len + encoded_len + 2 > max_encoded_length) {
424
			/* It won't fit with trailing "?=" --- break the line */
425
			strbuf_addf(sb, "?=\n =?%s?q?", encoding);
426
			line_len = strlen(encoding) + 5 + 1; /* =??q? plus SP */
427
		}
428

429
		for (i = 0; i < chrlen; i++)
430
			strbuf_addf(sb, encoded_fmt, p[i]);
431
		line_len += encoded_len;
432
	}
433
	strbuf_addstr(sb, "?=");
434
}
435

436
const char *show_ident_date(const struct ident_split *ident,
437
			    struct date_mode mode)
438
{
439
	timestamp_t date = 0;
440
	long tz = 0;
441

442
	if (ident->date_begin && ident->date_end)
443
		date = parse_timestamp(ident->date_begin, NULL, 10);
444
	if (date_overflows(date))
445
		date = 0;
446
	else {
447
		if (ident->tz_begin && ident->tz_end)
448
			tz = strtol(ident->tz_begin, NULL, 10);
449
		if (tz >= INT_MAX || tz <= INT_MIN)
450
			tz = 0;
451
	}
452
	return show_date(date, tz, mode);
453
}
454

455
static inline void strbuf_add_with_color(struct strbuf *sb, const char *color,
456
					 const char *buf, size_t buflen)
457
{
458
	strbuf_addstr(sb, color);
459
	strbuf_add(sb, buf, buflen);
460
	if (*color)
461
		strbuf_addstr(sb, GIT_COLOR_RESET);
462
}
463

464
static void append_line_with_color(struct strbuf *sb, struct grep_opt *opt,
465
				   const char *line, size_t linelen,
466
				   int color, enum grep_context ctx,
467
				   enum grep_header_field field)
468
{
469
	const char *buf, *eol, *line_color, *match_color;
470
	regmatch_t match;
471
	int eflags = 0;
472

473
	buf = line;
474
	eol = buf + linelen;
475

476
	if (!opt || !want_color(color) || opt->invert)
477
		goto end;
478

479
	line_color = opt->colors[GREP_COLOR_SELECTED];
480
	match_color = opt->colors[GREP_COLOR_MATCH_SELECTED];
481

482
	while (grep_next_match(opt, buf, eol, ctx, &match, field, eflags)) {
483
		if (match.rm_so == match.rm_eo)
484
			break;
485

486
		strbuf_add_with_color(sb, line_color, buf, match.rm_so);
487
		strbuf_add_with_color(sb, match_color, buf + match.rm_so,
488
				      match.rm_eo - match.rm_so);
489
		buf += match.rm_eo;
490
		eflags = REG_NOTBOL;
491
	}
492

493
	if (eflags)
494
		strbuf_add_with_color(sb, line_color, buf, eol - buf);
495
	else {
496
end:
497
		strbuf_add(sb, buf, eol - buf);
498
	}
499
}
500

501
static int use_in_body_from(const struct pretty_print_context *pp,
502
			    const struct ident_split *ident)
503
{
504
	if (pp->rev && pp->rev->force_in_body_from)
505
		return 1;
506
	if (ident_cmp(pp->from_ident, ident))
507
		return 1;
508
	return 0;
509
}
510

511
void pp_user_info(struct pretty_print_context *pp,
512
		  const char *what, struct strbuf *sb,
513
		  const char *line, const char *encoding)
514
{
515
	struct ident_split ident;
516
	char *line_end;
517
	const char *mailbuf, *namebuf;
518
	size_t namelen, maillen;
519
	int max_length = 78; /* per rfc2822 */
520

521
	if (pp->fmt == CMIT_FMT_ONELINE)
522
		return;
523

524
	line_end = strchrnul(line, '\n');
525
	if (split_ident_line(&ident, line, line_end - line))
526
		return;
527

528
	mailbuf = ident.mail_begin;
529
	maillen = ident.mail_end - ident.mail_begin;
530
	namebuf = ident.name_begin;
531
	namelen = ident.name_end - ident.name_begin;
532

533
	if (pp->mailmap)
534
		map_user(pp->mailmap, &mailbuf, &maillen, &namebuf, &namelen);
535

536
	if (cmit_fmt_is_mail(pp->fmt)) {
537
		if (pp->from_ident && use_in_body_from(pp, &ident)) {
538
			struct strbuf buf = STRBUF_INIT;
539

540
			strbuf_addstr(&buf, "From: ");
541
			strbuf_add(&buf, namebuf, namelen);
542
			strbuf_addstr(&buf, " <");
543
			strbuf_add(&buf, mailbuf, maillen);
544
			strbuf_addstr(&buf, ">\n");
545
			string_list_append(&pp->in_body_headers,
546
					   strbuf_detach(&buf, NULL));
547

548
			mailbuf = pp->from_ident->mail_begin;
549
			maillen = pp->from_ident->mail_end - mailbuf;
550
			namebuf = pp->from_ident->name_begin;
551
			namelen = pp->from_ident->name_end - namebuf;
552
		}
553

554
		strbuf_addstr(sb, "From: ");
555
		if (pp->encode_email_headers &&
556
		    needs_rfc2047_encoding(namebuf, namelen)) {
557
			add_rfc2047(sb, namebuf, namelen,
558
				    encoding, RFC2047_ADDRESS);
559
			max_length = 76; /* per rfc2047 */
560
		} else if (needs_rfc822_quoting(namebuf, namelen)) {
561
			struct strbuf quoted = STRBUF_INIT;
562
			add_rfc822_quoted(&quoted, namebuf, namelen);
563
			strbuf_add_wrapped_bytes(sb, quoted.buf, quoted.len,
564
							-6, 1, max_length);
565
			strbuf_release(&quoted);
566
		} else {
567
			strbuf_add_wrapped_bytes(sb, namebuf, namelen,
568
						 -6, 1, max_length);
569
		}
570

571
		if (max_length <
572
		    last_line_length(sb) + strlen(" <") + maillen + strlen(">"))
573
			strbuf_addch(sb, '\n');
574
		strbuf_addf(sb, " <%.*s>\n", (int)maillen, mailbuf);
575
	} else {
576
		struct strbuf id = STRBUF_INIT;
577
		enum grep_header_field field = GREP_HEADER_FIELD_MAX;
578
		struct grep_opt *opt = pp->rev ? &pp->rev->grep_filter : NULL;
579

580
		if (!strcmp(what, "Author"))
581
			field = GREP_HEADER_AUTHOR;
582
		else if (!strcmp(what, "Commit"))
583
			field = GREP_HEADER_COMMITTER;
584

585
		strbuf_addf(sb, "%s: ", what);
586
		if (pp->fmt == CMIT_FMT_FULLER)
587
			strbuf_addchars(sb, ' ', 4);
588

589
		strbuf_addf(&id, "%.*s <%.*s>", (int)namelen, namebuf,
590
			    (int)maillen, mailbuf);
591

592
		append_line_with_color(sb, opt, id.buf, id.len, pp->color,
593
				       GREP_CONTEXT_HEAD, field);
594
		strbuf_addch(sb, '\n');
595
		strbuf_release(&id);
596
	}
597

598
	switch (pp->fmt) {
599
	case CMIT_FMT_MEDIUM:
600
		strbuf_addf(sb, "Date:   %s\n",
601
			    show_ident_date(&ident, pp->date_mode));
602
		break;
603
	case CMIT_FMT_EMAIL:
604
	case CMIT_FMT_MBOXRD:
605
		strbuf_addf(sb, "Date: %s\n",
606
			    show_ident_date(&ident, DATE_MODE(RFC2822)));
607
		break;
608
	case CMIT_FMT_FULLER:
609
		strbuf_addf(sb, "%sDate: %s\n", what,
610
			    show_ident_date(&ident, pp->date_mode));
611
		break;
612
	default:
613
		/* notin' */
614
		break;
615
	}
616
}
617

618
static int is_blank_line(const char *line, int *len_p)
619
{
620
	int len = *len_p;
621
	while (len && isspace(line[len - 1]))
622
		len--;
623
	*len_p = len;
624
	return !len;
625
}
626

627
const char *skip_blank_lines(const char *msg)
628
{
629
	for (;;) {
630
		int linelen = get_one_line(msg);
631
		int ll = linelen;
632
		if (!linelen)
633
			break;
634
		if (!is_blank_line(msg, &ll))
635
			break;
636
		msg += linelen;
637
	}
638
	return msg;
639
}
640

641
static void add_merge_info(const struct pretty_print_context *pp,
642
			   struct strbuf *sb, const struct commit *commit)
643
{
644
	struct commit_list *parent = commit->parents;
645

646
	if ((pp->fmt == CMIT_FMT_ONELINE) || (cmit_fmt_is_mail(pp->fmt)) ||
647
	    !parent || !parent->next)
648
		return;
649

650
	strbuf_addstr(sb, "Merge:");
651

652
	while (parent) {
653
		struct object_id *oidp = &parent->item->object.oid;
654
		strbuf_addch(sb, ' ');
655
		if (pp->abbrev)
656
			strbuf_add_unique_abbrev(sb, oidp, pp->abbrev);
657
		else
658
			strbuf_addstr(sb, oid_to_hex(oidp));
659
		parent = parent->next;
660
	}
661
	strbuf_addch(sb, '\n');
662
}
663

664
static char *get_header(const char *msg, const char *key)
665
{
666
	size_t len;
667
	const char *v = find_commit_header(msg, key, &len);
668
	return v ? xmemdupz(v, len) : NULL;
669
}
670

671
static char *replace_encoding_header(char *buf, const char *encoding)
672
{
673
	struct strbuf tmp = STRBUF_INIT;
674
	size_t start, len;
675
	char *cp = buf;
676

677
	/* guess if there is an encoding header before a \n\n */
678
	while (!starts_with(cp, "encoding ")) {
679
		cp = strchr(cp, '\n');
680
		if (!cp || *++cp == '\n')
681
			return buf;
682
	}
683
	start = cp - buf;
684
	cp = strchr(cp, '\n');
685
	if (!cp)
686
		return buf; /* should not happen but be defensive */
687
	len = cp + 1 - (buf + start);
688

689
	strbuf_attach(&tmp, buf, strlen(buf), strlen(buf) + 1);
690
	if (is_encoding_utf8(encoding)) {
691
		/* we have re-coded to UTF-8; drop the header */
692
		strbuf_remove(&tmp, start, len);
693
	} else {
694
		/* just replaces XXXX in 'encoding XXXX\n' */
695
		strbuf_splice(&tmp, start + strlen("encoding "),
696
					  len - strlen("encoding \n"),
697
					  encoding, strlen(encoding));
698
	}
699
	return strbuf_detach(&tmp, NULL);
700
}
701

702
const char *repo_logmsg_reencode(struct repository *r,
703
				 const struct commit *commit,
704
				 char **commit_encoding,
705
				 const char *output_encoding)
706
{
707
	static const char *utf8 = "UTF-8";
708
	const char *use_encoding;
709
	char *encoding;
710
	const char *msg = repo_get_commit_buffer(r, commit, NULL);
711
	char *out;
712

713
	if (!output_encoding || !*output_encoding) {
714
		if (commit_encoding)
715
			*commit_encoding = get_header(msg, "encoding");
716
		return msg;
717
	}
718
	encoding = get_header(msg, "encoding");
719
	if (commit_encoding)
720
		*commit_encoding = encoding;
721
	use_encoding = encoding ? encoding : utf8;
722
	if (same_encoding(use_encoding, output_encoding)) {
723
		/*
724
		 * No encoding work to be done. If we have no encoding header
725
		 * at all, then there's nothing to do, and we can return the
726
		 * message verbatim (whether newly allocated or not).
727
		 */
728
		if (!encoding)
729
			return msg;
730

731
		/*
732
		 * Otherwise, we still want to munge the encoding header in the
733
		 * result, which will be done by modifying the buffer. If we
734
		 * are using a fresh copy, we can reuse it. But if we are using
735
		 * the cached copy from repo_get_commit_buffer, we need to duplicate it
736
		 * to avoid munging the cached copy.
737
		 */
738
		if (msg == get_cached_commit_buffer(r, commit, NULL))
739
			out = xstrdup(msg);
740
		else
741
			out = (char *)msg;
742
	}
743
	else {
744
		/*
745
		 * There's actual encoding work to do. Do the reencoding, which
746
		 * still leaves the header to be replaced in the next step. At
747
		 * this point, we are done with msg. If we allocated a fresh
748
		 * copy, we can free it.
749
		 */
750
		out = reencode_string(msg, output_encoding, use_encoding);
751
		if (out)
752
			repo_unuse_commit_buffer(r, commit, msg);
753
	}
754

755
	/*
756
	 * This replacement actually consumes the buffer we hand it, so we do
757
	 * not have to worry about freeing the old "out" here.
758
	 */
759
	if (out)
760
		out = replace_encoding_header(out, output_encoding);
761

762
	if (!commit_encoding)
763
		free(encoding);
764
	/*
765
	 * If the re-encoding failed, out might be NULL here; in that
766
	 * case we just return the commit message verbatim.
767
	 */
768
	return out ? out : msg;
769
}
770

771
static int mailmap_name(const char **email, size_t *email_len,
772
			const char **name, size_t *name_len)
773
{
774
	static struct string_list *mail_map;
775
	if (!mail_map) {
776
		CALLOC_ARRAY(mail_map, 1);
777
		read_mailmap(mail_map);
778
	}
779
	return mail_map->nr && map_user(mail_map, email, email_len, name, name_len);
780
}
781

782
static size_t format_person_part(struct strbuf *sb, char part,
783
				 const char *msg, int len,
784
				 struct date_mode dmode)
785
{
786
	/* currently all placeholders have same length */
787
	const int placeholder_len = 2;
788
	struct ident_split s;
789
	const char *name, *mail;
790
	size_t maillen, namelen;
791

792
	if (split_ident_line(&s, msg, len) < 0)
793
		goto skip;
794

795
	name = s.name_begin;
796
	namelen = s.name_end - s.name_begin;
797
	mail = s.mail_begin;
798
	maillen = s.mail_end - s.mail_begin;
799

800
	if (part == 'N' || part == 'E' || part == 'L') /* mailmap lookup */
801
		mailmap_name(&mail, &maillen, &name, &namelen);
802
	if (part == 'n' || part == 'N') {	/* name */
803
		strbuf_add(sb, name, namelen);
804
		return placeholder_len;
805
	}
806
	if (part == 'e' || part == 'E') {	/* email */
807
		strbuf_add(sb, mail, maillen);
808
		return placeholder_len;
809
	}
810
	if (part == 'l' || part == 'L') {	/* local-part */
811
		const char *at = memchr(mail, '@', maillen);
812
		if (at)
813
			maillen = at - mail;
814
		strbuf_add(sb, mail, maillen);
815
		return placeholder_len;
816
	}
817

818
	if (!s.date_begin)
819
		goto skip;
820

821
	if (part == 't') {	/* date, UNIX timestamp */
822
		strbuf_add(sb, s.date_begin, s.date_end - s.date_begin);
823
		return placeholder_len;
824
	}
825

826
	switch (part) {
827
	case 'd':	/* date */
828
		strbuf_addstr(sb, show_ident_date(&s, dmode));
829
		return placeholder_len;
830
	case 'D':	/* date, RFC2822 style */
831
		strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(RFC2822)));
832
		return placeholder_len;
833
	case 'r':	/* date, relative */
834
		strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(RELATIVE)));
835
		return placeholder_len;
836
	case 'i':	/* date, ISO 8601-like */
837
		strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(ISO8601)));
838
		return placeholder_len;
839
	case 'I':	/* date, ISO 8601 strict */
840
		strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(ISO8601_STRICT)));
841
		return placeholder_len;
842
	case 'h':	/* date, human */
843
		strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(HUMAN)));
844
		return placeholder_len;
845
	case 's':
846
		strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(SHORT)));
847
		return placeholder_len;
848
	}
849

850
skip:
851
	/*
852
	 * reading from either a bogus commit, or a reflog entry with
853
	 * %gn, %ge, etc.; 'sb' cannot be updated, but we still need
854
	 * to compute a valid return value.
855
	 */
856
	if (part == 'n' || part == 'e' || part == 't' || part == 'd'
857
	    || part == 'D' || part == 'r' || part == 'i')
858
		return placeholder_len;
859

860
	return 0; /* unknown placeholder */
861
}
862

863
struct chunk {
864
	size_t off;
865
	size_t len;
866
};
867

868
enum flush_type {
869
	no_flush,
870
	flush_right,
871
	flush_left,
872
	flush_left_and_steal,
873
	flush_both
874
};
875

876
enum trunc_type {
877
	trunc_none,
878
	trunc_left,
879
	trunc_middle,
880
	trunc_right
881
};
882

883
struct format_commit_context {
884
	struct repository *repository;
885
	const struct commit *commit;
886
	const struct pretty_print_context *pretty_ctx;
887
	unsigned commit_header_parsed:1;
888
	unsigned commit_message_parsed:1;
889
	struct signature_check signature_check;
890
	enum flush_type flush_type;
891
	enum trunc_type truncate;
892
	const char *message;
893
	char *commit_encoding;
894
	size_t width, indent1, indent2;
895
	int auto_color;
896
	int padding;
897

898
	/* These offsets are relative to the start of the commit message. */
899
	struct chunk author;
900
	struct chunk committer;
901
	size_t message_off;
902
	size_t subject_off;
903
	size_t body_off;
904

905
	/* The following ones are relative to the result struct strbuf. */
906
	size_t wrap_start;
907
};
908

909
static void parse_commit_header(struct format_commit_context *context)
910
{
911
	const char *msg = context->message;
912
	int i;
913

914
	for (i = 0; msg[i]; i++) {
915
		const char *name;
916
		int eol;
917
		for (eol = i; msg[eol] && msg[eol] != '\n'; eol++)
918
			; /* do nothing */
919

920
		if (i == eol) {
921
			break;
922
		} else if (skip_prefix(msg + i, "author ", &name)) {
923
			context->author.off = name - msg;
924
			context->author.len = msg + eol - name;
925
		} else if (skip_prefix(msg + i, "committer ", &name)) {
926
			context->committer.off = name - msg;
927
			context->committer.len = msg + eol - name;
928
		}
929
		i = eol;
930
	}
931
	context->message_off = i;
932
	context->commit_header_parsed = 1;
933
}
934

935
static int istitlechar(char c)
936
{
937
	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
938
		(c >= '0' && c <= '9') || c == '.' || c == '_';
939
}
940

941
void format_sanitized_subject(struct strbuf *sb, const char *msg, size_t len)
942
{
943
	size_t trimlen;
944
	size_t start_len = sb->len;
945
	int space = 2;
946
	int i;
947

948
	for (i = 0; i < len; i++) {
949
		if (istitlechar(msg[i])) {
950
			if (space == 1)
951
				strbuf_addch(sb, '-');
952
			space = 0;
953
			strbuf_addch(sb, msg[i]);
954
			if (msg[i] == '.')
955
				while (msg[i+1] == '.')
956
					i++;
957
		} else
958
			space |= 1;
959
	}
960

961
	/* trim any trailing '.' or '-' characters */
962
	trimlen = 0;
963
	while (sb->len - trimlen > start_len &&
964
		(sb->buf[sb->len - 1 - trimlen] == '.'
965
		|| sb->buf[sb->len - 1 - trimlen] == '-'))
966
		trimlen++;
967
	strbuf_remove(sb, sb->len - trimlen, trimlen);
968
}
969

970
const char *format_subject(struct strbuf *sb, const char *msg,
971
			   const char *line_separator)
972
{
973
	int first = 1;
974

975
	for (;;) {
976
		const char *line = msg;
977
		int linelen = get_one_line(line);
978

979
		msg += linelen;
980
		if (!linelen || is_blank_line(line, &linelen))
981
			break;
982

983
		if (!sb)
984
			continue;
985
		strbuf_grow(sb, linelen + 2);
986
		if (!first)
987
			strbuf_addstr(sb, line_separator);
988
		strbuf_add(sb, line, linelen);
989
		first = 0;
990
	}
991
	return msg;
992
}
993

994
static void parse_commit_message(struct format_commit_context *c)
995
{
996
	const char *msg = c->message + c->message_off;
997
	const char *start = c->message;
998

999
	msg = skip_blank_lines(msg);
1000
	c->subject_off = msg - start;
1001

1002
	msg = format_subject(NULL, msg, NULL);
1003
	msg = skip_blank_lines(msg);
1004
	c->body_off = msg - start;
1005

1006
	c->commit_message_parsed = 1;
1007
}
1008

1009
static void strbuf_wrap(struct strbuf *sb, size_t pos,
1010
			size_t width, size_t indent1, size_t indent2)
1011
{
1012
	struct strbuf tmp = STRBUF_INIT;
1013

1014
	if (pos)
1015
		strbuf_add(&tmp, sb->buf, pos);
1016
	strbuf_add_wrapped_text(&tmp, sb->buf + pos,
1017
				cast_size_t_to_int(indent1),
1018
				cast_size_t_to_int(indent2),
1019
				cast_size_t_to_int(width));
1020
	strbuf_swap(&tmp, sb);
1021
	strbuf_release(&tmp);
1022
}
1023

1024
static void rewrap_message_tail(struct strbuf *sb,
1025
				struct format_commit_context *c,
1026
				size_t new_width, size_t new_indent1,
1027
				size_t new_indent2)
1028
{
1029
	if (c->width == new_width && c->indent1 == new_indent1 &&
1030
	    c->indent2 == new_indent2)
1031
		return;
1032
	if (c->wrap_start < sb->len)
1033
		strbuf_wrap(sb, c->wrap_start, c->width, c->indent1, c->indent2);
1034
	c->wrap_start = sb->len;
1035
	c->width = new_width;
1036
	c->indent1 = new_indent1;
1037
	c->indent2 = new_indent2;
1038
}
1039

1040
static int format_reflog_person(struct strbuf *sb,
1041
				char part,
1042
				struct reflog_walk_info *log,
1043
				struct date_mode dmode)
1044
{
1045
	const char *ident;
1046

1047
	if (!log)
1048
		return 2;
1049

1050
	ident = get_reflog_ident(log);
1051
	if (!ident)
1052
		return 2;
1053

1054
	return format_person_part(sb, part, ident, strlen(ident), dmode);
1055
}
1056

1057
static size_t parse_color(struct strbuf *sb, /* in UTF-8 */
1058
			  const char *placeholder,
1059
			  struct format_commit_context *c)
1060
{
1061
	const char *rest = placeholder;
1062
	const char *basic_color = NULL;
1063

1064
	if (placeholder[1] == '(') {
1065
		const char *begin = placeholder + 2;
1066
		const char *end = strchr(begin, ')');
1067
		char color[COLOR_MAXLEN];
1068

1069
		if (!end)
1070
			return 0;
1071

1072
		if (skip_prefix(begin, "auto,", &begin)) {
1073
			if (!want_color(c->pretty_ctx->color))
1074
				return end - placeholder + 1;
1075
		} else if (skip_prefix(begin, "always,", &begin)) {
1076
			/* nothing to do; we do not respect want_color at all */
1077
		} else {
1078
			/* the default is the same as "auto" */
1079
			if (!want_color(c->pretty_ctx->color))
1080
				return end - placeholder + 1;
1081
		}
1082

1083
		if (color_parse_mem(begin, end - begin, color) < 0)
1084
			die(_("unable to parse --pretty format"));
1085
		strbuf_addstr(sb, color);
1086
		return end - placeholder + 1;
1087
	}
1088

1089
	/*
1090
	 * We handle things like "%C(red)" above; for historical reasons, there
1091
	 * are a few colors that can be specified without parentheses (and
1092
	 * they cannot support things like "auto" or "always" at all).
1093
	 */
1094
	if (skip_prefix(placeholder + 1, "red", &rest))
1095
		basic_color = GIT_COLOR_RED;
1096
	else if (skip_prefix(placeholder + 1, "green", &rest))
1097
		basic_color = GIT_COLOR_GREEN;
1098
	else if (skip_prefix(placeholder + 1, "blue", &rest))
1099
		basic_color = GIT_COLOR_BLUE;
1100
	else if (skip_prefix(placeholder + 1, "reset", &rest))
1101
		basic_color = GIT_COLOR_RESET;
1102

1103
	if (basic_color && want_color(c->pretty_ctx->color))
1104
		strbuf_addstr(sb, basic_color);
1105

1106
	return rest - placeholder;
1107
}
1108

1109
static size_t parse_padding_placeholder(const char *placeholder,
1110
					struct format_commit_context *c)
1111
{
1112
	const char *ch = placeholder;
1113
	enum flush_type flush_type;
1114
	int to_column = 0;
1115

1116
	switch (*ch++) {
1117
	case '<':
1118
		flush_type = flush_right;
1119
		break;
1120
	case '>':
1121
		if (*ch == '<') {
1122
			flush_type = flush_both;
1123
			ch++;
1124
		} else if (*ch == '>') {
1125
			flush_type = flush_left_and_steal;
1126
			ch++;
1127
		} else
1128
			flush_type = flush_left;
1129
		break;
1130
	default:
1131
		return 0;
1132
	}
1133

1134
	/* the next value means "wide enough to that column" */
1135
	if (*ch == '|') {
1136
		to_column = 1;
1137
		ch++;
1138
	}
1139

1140
	if (*ch == '(') {
1141
		const char *start = ch + 1;
1142
		const char *end = start + strcspn(start, ",)");
1143
		char *next;
1144
		int width;
1145
		if (!*end || end == start)
1146
			return 0;
1147
		width = strtol(start, &next, 10);
1148

1149
		/*
1150
		 * We need to limit the amount of padding, or otherwise this
1151
		 * would allow the user to pad the buffer by arbitrarily many
1152
		 * bytes and thus cause resource exhaustion.
1153
		 */
1154
		if (width < -FORMATTING_LIMIT || width > FORMATTING_LIMIT)
1155
			return 0;
1156

1157
		if (next == start || width == 0)
1158
			return 0;
1159
		if (width < 0) {
1160
			if (to_column)
1161
				width += term_columns();
1162
			if (width < 0)
1163
				return 0;
1164
		}
1165
		c->padding = to_column ? -width : width;
1166
		c->flush_type = flush_type;
1167

1168
		if (*end == ',') {
1169
			start = end + 1;
1170
			end = strchr(start, ')');
1171
			if (!end || end == start)
1172
				return 0;
1173
			if (starts_with(start, "trunc)"))
1174
				c->truncate = trunc_right;
1175
			else if (starts_with(start, "ltrunc)"))
1176
				c->truncate = trunc_left;
1177
			else if (starts_with(start, "mtrunc)"))
1178
				c->truncate = trunc_middle;
1179
			else
1180
				return 0;
1181
		} else
1182
			c->truncate = trunc_none;
1183

1184
		return end - placeholder + 1;
1185
	}
1186
	return 0;
1187
}
1188

1189
static int match_placeholder_arg_value(const char *to_parse, const char *candidate,
1190
				       const char **end, const char **valuestart,
1191
				       size_t *valuelen)
1192
{
1193
	const char *p;
1194

1195
	if (!(skip_prefix(to_parse, candidate, &p)))
1196
		return 0;
1197
	if (valuestart) {
1198
		if (*p == '=') {
1199
			*valuestart = p + 1;
1200
			*valuelen = strcspn(*valuestart, ",)");
1201
			p = *valuestart + *valuelen;
1202
		} else {
1203
			if (*p != ',' && *p != ')')
1204
				return 0;
1205
			*valuestart = NULL;
1206
			*valuelen = 0;
1207
		}
1208
	}
1209
	if (*p == ',') {
1210
		*end = p + 1;
1211
		return 1;
1212
	}
1213
	if (*p == ')') {
1214
		*end = p;
1215
		return 1;
1216
	}
1217
	return 0;
1218
}
1219

1220
static int match_placeholder_bool_arg(const char *to_parse, const char *candidate,
1221
				      const char **end, int *val)
1222
{
1223
	const char *argval;
1224
	char *strval;
1225
	size_t arglen;
1226
	int v;
1227

1228
	if (!match_placeholder_arg_value(to_parse, candidate, end, &argval, &arglen))
1229
		return 0;
1230

1231
	if (!argval) {
1232
		*val = 1;
1233
		return 1;
1234
	}
1235

1236
	strval = xstrndup(argval, arglen);
1237
	v = git_parse_maybe_bool(strval);
1238
	free(strval);
1239

1240
	if (v == -1)
1241
		return 0;
1242

1243
	*val = v;
1244

1245
	return 1;
1246
}
1247

1248
static int format_trailer_match_cb(const struct strbuf *key, void *ud)
1249
{
1250
	const struct string_list *list = ud;
1251
	const struct string_list_item *item;
1252

1253
	for_each_string_list_item (item, list) {
1254
		if (key->len == (uintptr_t)item->util &&
1255
		    !strncasecmp(item->string, key->buf, key->len))
1256
			return 1;
1257
	}
1258
	return 0;
1259
}
1260

1261
static struct strbuf *expand_string_arg(struct strbuf *sb,
1262
					const char *argval, size_t arglen)
1263
{
1264
	char *fmt = xstrndup(argval, arglen);
1265
	const char *format = fmt;
1266

1267
	strbuf_reset(sb);
1268
	while (strbuf_expand_step(sb, &format)) {
1269
		size_t len;
1270

1271
		if (skip_prefix(format, "%", &format))
1272
			strbuf_addch(sb, '%');
1273
		else if ((len = strbuf_expand_literal(sb, format)))
1274
			format += len;
1275
		else
1276
			strbuf_addch(sb, '%');
1277
	}
1278
	free(fmt);
1279
	return sb;
1280
}
1281

1282
int format_set_trailers_options(struct process_trailer_options *opts,
1283
				struct string_list *filter_list,
1284
				struct strbuf *sepbuf,
1285
				struct strbuf *kvsepbuf,
1286
				const char **arg,
1287
				char **invalid_arg)
1288
{
1289
	for (;;) {
1290
		const char *argval;
1291
		size_t arglen;
1292

1293
		if (**arg == ')')
1294
			break;
1295

1296
		if (match_placeholder_arg_value(*arg, "key", arg, &argval, &arglen)) {
1297
			uintptr_t len = arglen;
1298

1299
			if (!argval)
1300
				return -1;
1301

1302
			if (len && argval[len - 1] == ':')
1303
				len--;
1304
			string_list_append(filter_list, argval)->util = (char *)len;
1305

1306
			opts->filter = format_trailer_match_cb;
1307
			opts->filter_data = filter_list;
1308
			opts->only_trailers = 1;
1309
		} else if (match_placeholder_arg_value(*arg, "separator", arg, &argval, &arglen)) {
1310
			opts->separator = expand_string_arg(sepbuf, argval, arglen);
1311
		} else if (match_placeholder_arg_value(*arg, "key_value_separator", arg, &argval, &arglen)) {
1312
			opts->key_value_separator = expand_string_arg(kvsepbuf, argval, arglen);
1313
		} else if (!match_placeholder_bool_arg(*arg, "only", arg, &opts->only_trailers) &&
1314
			   !match_placeholder_bool_arg(*arg, "unfold", arg, &opts->unfold) &&
1315
			   !match_placeholder_bool_arg(*arg, "keyonly", arg, &opts->key_only) &&
1316
			   !match_placeholder_bool_arg(*arg, "valueonly", arg, &opts->value_only)) {
1317
			if (invalid_arg) {
1318
				size_t len = strcspn(*arg, ",)");
1319
				*invalid_arg = xstrndup(*arg, len);
1320
			}
1321
			return -1;
1322
		}
1323
	}
1324
	return 0;
1325
}
1326

1327
static size_t parse_describe_args(const char *start, struct strvec *args)
1328
{
1329
	struct {
1330
		const char *name;
1331
		enum {
1332
			DESCRIBE_ARG_BOOL,
1333
			DESCRIBE_ARG_INTEGER,
1334
			DESCRIBE_ARG_STRING,
1335
		} type;
1336
	}  option[] = {
1337
		{ "tags", DESCRIBE_ARG_BOOL},
1338
		{ "abbrev", DESCRIBE_ARG_INTEGER },
1339
		{ "exclude", DESCRIBE_ARG_STRING },
1340
		{ "match", DESCRIBE_ARG_STRING },
1341
	};
1342
	const char *arg = start;
1343

1344
	for (;;) {
1345
		int found = 0;
1346
		const char *argval;
1347
		size_t arglen = 0;
1348
		int optval = 0;
1349
		int i;
1350

1351
		for (i = 0; !found && i < ARRAY_SIZE(option); i++) {
1352
			switch (option[i].type) {
1353
			case DESCRIBE_ARG_BOOL:
1354
				if (match_placeholder_bool_arg(arg, option[i].name, &arg, &optval)) {
1355
					if (optval)
1356
						strvec_pushf(args, "--%s", option[i].name);
1357
					else
1358
						strvec_pushf(args, "--no-%s", option[i].name);
1359
					found = 1;
1360
				}
1361
				break;
1362
			case DESCRIBE_ARG_INTEGER:
1363
				if (match_placeholder_arg_value(arg, option[i].name, &arg,
1364
								&argval, &arglen)) {
1365
					char *endptr;
1366
					if (!arglen)
1367
						return 0;
1368
					strtol(argval, &endptr, 10);
1369
					if (endptr - argval != arglen)
1370
						return 0;
1371
					strvec_pushf(args, "--%s=%.*s", option[i].name, (int)arglen, argval);
1372
					found = 1;
1373
				}
1374
				break;
1375
			case DESCRIBE_ARG_STRING:
1376
				if (match_placeholder_arg_value(arg, option[i].name, &arg,
1377
								&argval, &arglen)) {
1378
					if (!arglen)
1379
						return 0;
1380
					strvec_pushf(args, "--%s=%.*s", option[i].name, (int)arglen, argval);
1381
					found = 1;
1382
				}
1383
				break;
1384
			}
1385
		}
1386
		if (!found)
1387
			break;
1388

1389
	}
1390
	return arg - start;
1391
}
1392

1393

1394
static int parse_decoration_option(const char **arg,
1395
				   const char *name,
1396
				   char **opt)
1397
{
1398
	const char *argval;
1399
	size_t arglen;
1400

1401
	if (match_placeholder_arg_value(*arg, name, arg, &argval, &arglen)) {
1402
		struct strbuf sb = STRBUF_INIT;
1403

1404
		expand_string_arg(&sb, argval, arglen);
1405
		*opt = strbuf_detach(&sb, NULL);
1406
		return 1;
1407
	}
1408
	return 0;
1409
}
1410

1411
static void parse_decoration_options(const char **arg,
1412
				     struct decoration_options *opts)
1413
{
1414
	while (parse_decoration_option(arg, "prefix", &opts->prefix) ||
1415
	       parse_decoration_option(arg, "suffix", &opts->suffix) ||
1416
	       parse_decoration_option(arg, "separator", &opts->separator) ||
1417
	       parse_decoration_option(arg, "pointer", &opts->pointer) ||
1418
	       parse_decoration_option(arg, "tag", &opts->tag))
1419
		;
1420
}
1421

1422
static void free_decoration_options(const struct decoration_options *opts)
1423
{
1424
	free(opts->prefix);
1425
	free(opts->suffix);
1426
	free(opts->separator);
1427
	free(opts->pointer);
1428
	free(opts->tag);
1429
}
1430

1431
static size_t format_commit_one(struct strbuf *sb, /* in UTF-8 */
1432
				const char *placeholder,
1433
				void *context)
1434
{
1435
	struct format_commit_context *c = context;
1436
	const struct commit *commit = c->commit;
1437
	const char *msg = c->message;
1438
	struct commit_list *p;
1439
	const char *arg, *eol;
1440
	size_t res;
1441
	char **slot;
1442

1443
	/* these are independent of the commit */
1444
	res = strbuf_expand_literal(sb, placeholder);
1445
	if (res)
1446
		return res;
1447

1448
	switch (placeholder[0]) {
1449
	case 'C':
1450
		if (starts_with(placeholder + 1, "(auto)")) {
1451
			c->auto_color = want_color(c->pretty_ctx->color);
1452
			if (c->auto_color && sb->len)
1453
				strbuf_addstr(sb, GIT_COLOR_RESET);
1454
			return 7; /* consumed 7 bytes, "C(auto)" */
1455
		} else {
1456
			int ret = parse_color(sb, placeholder, c);
1457
			if (ret)
1458
				c->auto_color = 0;
1459
			/*
1460
			 * Otherwise, we decided to treat %C<unknown>
1461
			 * as a literal string, and the previous
1462
			 * %C(auto) is still valid.
1463
			 */
1464
			return ret;
1465
		}
1466
	case 'w':
1467
		if (placeholder[1] == '(') {
1468
			unsigned long width = 0, indent1 = 0, indent2 = 0;
1469
			char *next;
1470
			const char *start = placeholder + 2;
1471
			const char *end = strchr(start, ')');
1472
			if (!end)
1473
				return 0;
1474
			if (end > start) {
1475
				width = strtoul(start, &next, 10);
1476
				if (*next == ',') {
1477
					indent1 = strtoul(next + 1, &next, 10);
1478
					if (*next == ',') {
1479
						indent2 = strtoul(next + 1,
1480
								 &next, 10);
1481
					}
1482
				}
1483
				if (*next != ')')
1484
					return 0;
1485
			}
1486

1487
			/*
1488
			 * We need to limit the format here as it allows the
1489
			 * user to prepend arbitrarily many bytes to the buffer
1490
			 * when rewrapping.
1491
			 */
1492
			if (width > FORMATTING_LIMIT ||
1493
			    indent1 > FORMATTING_LIMIT ||
1494
			    indent2 > FORMATTING_LIMIT)
1495
				return 0;
1496
			rewrap_message_tail(sb, c, width, indent1, indent2);
1497
			return end - placeholder + 1;
1498
		} else
1499
			return 0;
1500

1501
	case '<':
1502
	case '>':
1503
		return parse_padding_placeholder(placeholder, c);
1504
	}
1505

1506
	if (skip_prefix(placeholder, "(describe", &arg)) {
1507
		struct child_process cmd = CHILD_PROCESS_INIT;
1508
		struct strbuf out = STRBUF_INIT;
1509
		struct strbuf err = STRBUF_INIT;
1510
		struct pretty_print_describe_status *describe_status;
1511

1512
		describe_status = c->pretty_ctx->describe_status;
1513
		if (describe_status) {
1514
			if (!describe_status->max_invocations)
1515
				return 0;
1516
			describe_status->max_invocations--;
1517
		}
1518

1519
		cmd.git_cmd = 1;
1520
		strvec_push(&cmd.args, "describe");
1521

1522
		if (*arg == ':') {
1523
			arg++;
1524
			arg += parse_describe_args(arg, &cmd.args);
1525
		}
1526

1527
		if (*arg != ')') {
1528
			child_process_clear(&cmd);
1529
			return 0;
1530
		}
1531

1532
		strvec_push(&cmd.args, oid_to_hex(&commit->object.oid));
1533
		pipe_command(&cmd, NULL, 0, &out, 0, &err, 0);
1534
		strbuf_rtrim(&out);
1535
		strbuf_addbuf(sb, &out);
1536
		strbuf_release(&out);
1537
		strbuf_release(&err);
1538
		return arg - placeholder + 1;
1539
	}
1540

1541
	/* these depend on the commit */
1542
	if (!commit->object.parsed)
1543
		parse_object(the_repository, &commit->object.oid);
1544

1545
	switch (placeholder[0]) {
1546
	case 'H':		/* commit hash */
1547
		strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_COMMIT));
1548
		strbuf_addstr(sb, oid_to_hex(&commit->object.oid));
1549
		strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
1550
		return 1;
1551
	case 'h':		/* abbreviated commit hash */
1552
		strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_COMMIT));
1553
		strbuf_add_unique_abbrev(sb, &commit->object.oid,
1554
					 c->pretty_ctx->abbrev);
1555
		strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
1556
		return 1;
1557
	case 'T':		/* tree hash */
1558
		strbuf_addstr(sb, oid_to_hex(get_commit_tree_oid(commit)));
1559
		return 1;
1560
	case 't':		/* abbreviated tree hash */
1561
		strbuf_add_unique_abbrev(sb,
1562
					 get_commit_tree_oid(commit),
1563
					 c->pretty_ctx->abbrev);
1564
		return 1;
1565
	case 'P':		/* parent hashes */
1566
		for (p = commit->parents; p; p = p->next) {
1567
			if (p != commit->parents)
1568
				strbuf_addch(sb, ' ');
1569
			strbuf_addstr(sb, oid_to_hex(&p->item->object.oid));
1570
		}
1571
		return 1;
1572
	case 'p':		/* abbreviated parent hashes */
1573
		for (p = commit->parents; p; p = p->next) {
1574
			if (p != commit->parents)
1575
				strbuf_addch(sb, ' ');
1576
			strbuf_add_unique_abbrev(sb, &p->item->object.oid,
1577
						 c->pretty_ctx->abbrev);
1578
		}
1579
		return 1;
1580
	case 'm':		/* left/right/bottom */
1581
		strbuf_addstr(sb, get_revision_mark(NULL, commit));
1582
		return 1;
1583
	case 'd':
1584
		format_decorations(sb, commit, c->auto_color, NULL);
1585
		return 1;
1586
	case 'D':
1587
		{
1588
			const struct decoration_options opts = {
1589
				.prefix = (char *) "",
1590
				.suffix = (char *) "",
1591
			};
1592

1593
			format_decorations(sb, commit, c->auto_color, &opts);
1594
			return 1;
1595
		}
1596
	case 'S':		/* tag/branch like --source */
1597
		if (!(c->pretty_ctx->rev && c->pretty_ctx->rev->sources))
1598
			return 0;
1599
		slot = revision_sources_at(c->pretty_ctx->rev->sources, commit);
1600
		if (!(slot && *slot))
1601
			return 0;
1602
		strbuf_addstr(sb, *slot);
1603
		return 1;
1604
	case 'g':		/* reflog info */
1605
		switch(placeholder[1]) {
1606
		case 'd':	/* reflog selector */
1607
		case 'D':
1608
			if (c->pretty_ctx->reflog_info)
1609
				get_reflog_selector(sb,
1610
						    c->pretty_ctx->reflog_info,
1611
						    c->pretty_ctx->date_mode,
1612
						    c->pretty_ctx->date_mode_explicit,
1613
						    (placeholder[1] == 'd'));
1614
			return 2;
1615
		case 's':	/* reflog message */
1616
			if (c->pretty_ctx->reflog_info)
1617
				get_reflog_message(sb, c->pretty_ctx->reflog_info);
1618
			return 2;
1619
		case 'n':
1620
		case 'N':
1621
		case 'e':
1622
		case 'E':
1623
			return format_reflog_person(sb,
1624
						    placeholder[1],
1625
						    c->pretty_ctx->reflog_info,
1626
						    c->pretty_ctx->date_mode);
1627
		}
1628
		return 0;	/* unknown %g placeholder */
1629
	case 'N':
1630
		if (c->pretty_ctx->notes_message) {
1631
			strbuf_addstr(sb, c->pretty_ctx->notes_message);
1632
			return 1;
1633
		}
1634
		return 0;
1635
	}
1636

1637
	if (placeholder[0] == 'G') {
1638
		if (!c->signature_check.result)
1639
			check_commit_signature(c->commit, &(c->signature_check));
1640
		switch (placeholder[1]) {
1641
		case 'G':
1642
			if (c->signature_check.output)
1643
				strbuf_addstr(sb, c->signature_check.output);
1644
			break;
1645
		case '?':
1646
			switch (c->signature_check.result) {
1647
			case 'G':
1648
				switch (c->signature_check.trust_level) {
1649
				case TRUST_UNDEFINED:
1650
				case TRUST_NEVER:
1651
					strbuf_addch(sb, 'U');
1652
					break;
1653
				default:
1654
					strbuf_addch(sb, 'G');
1655
					break;
1656
				}
1657
				break;
1658
			case 'B':
1659
			case 'E':
1660
			case 'N':
1661
			case 'X':
1662
			case 'Y':
1663
			case 'R':
1664
				strbuf_addch(sb, c->signature_check.result);
1665
			}
1666
			break;
1667
		case 'S':
1668
			if (c->signature_check.signer)
1669
				strbuf_addstr(sb, c->signature_check.signer);
1670
			break;
1671
		case 'K':
1672
			if (c->signature_check.key)
1673
				strbuf_addstr(sb, c->signature_check.key);
1674
			break;
1675
		case 'F':
1676
			if (c->signature_check.fingerprint)
1677
				strbuf_addstr(sb, c->signature_check.fingerprint);
1678
			break;
1679
		case 'P':
1680
			if (c->signature_check.primary_key_fingerprint)
1681
				strbuf_addstr(sb, c->signature_check.primary_key_fingerprint);
1682
			break;
1683
		case 'T':
1684
			strbuf_addstr(sb, gpg_trust_level_to_str(c->signature_check.trust_level));
1685
			break;
1686
		default:
1687
			return 0;
1688
		}
1689
		return 2;
1690
	}
1691

1692
	if (skip_prefix(placeholder, "(decorate", &arg)) {
1693
		struct decoration_options opts = { NULL };
1694
		size_t ret = 0;
1695

1696
		if (*arg == ':') {
1697
			arg++;
1698
			parse_decoration_options(&arg, &opts);
1699
		}
1700
		if (*arg == ')') {
1701
			format_decorations(sb, commit, c->auto_color, &opts);
1702
			ret = arg - placeholder + 1;
1703
		}
1704

1705
		free_decoration_options(&opts);
1706
		return ret;
1707
	}
1708

1709
	/* For the rest we have to parse the commit header. */
1710
	if (!c->commit_header_parsed) {
1711
		msg = c->message =
1712
			repo_logmsg_reencode(c->repository, commit,
1713
					     &c->commit_encoding, "UTF-8");
1714
		parse_commit_header(c);
1715
	}
1716

1717
	switch (placeholder[0]) {
1718
	case 'a':	/* author ... */
1719
		return format_person_part(sb, placeholder[1],
1720
				   msg + c->author.off, c->author.len,
1721
				   c->pretty_ctx->date_mode);
1722
	case 'c':	/* committer ... */
1723
		return format_person_part(sb, placeholder[1],
1724
				   msg + c->committer.off, c->committer.len,
1725
				   c->pretty_ctx->date_mode);
1726
	case 'e':	/* encoding */
1727
		if (c->commit_encoding)
1728
			strbuf_addstr(sb, c->commit_encoding);
1729
		return 1;
1730
	case 'B':	/* raw body */
1731
		/* message_off is always left at the initial newline */
1732
		strbuf_addstr(sb, msg + c->message_off + 1);
1733
		return 1;
1734
	}
1735

1736
	/* Now we need to parse the commit message. */
1737
	if (!c->commit_message_parsed)
1738
		parse_commit_message(c);
1739

1740
	switch (placeholder[0]) {
1741
	case 's':	/* subject */
1742
		format_subject(sb, msg + c->subject_off, " ");
1743
		return 1;
1744
	case 'f':	/* sanitized subject */
1745
		eol = strchrnul(msg + c->subject_off, '\n');
1746
		format_sanitized_subject(sb, msg + c->subject_off, eol - (msg + c->subject_off));
1747
		return 1;
1748
	case 'b':	/* body */
1749
		strbuf_addstr(sb, msg + c->body_off);
1750
		return 1;
1751
	}
1752

1753
	if (skip_prefix(placeholder, "(trailers", &arg)) {
1754
		struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
1755
		struct string_list filter_list = STRING_LIST_INIT_NODUP;
1756
		struct strbuf sepbuf = STRBUF_INIT;
1757
		struct strbuf kvsepbuf = STRBUF_INIT;
1758
		size_t ret = 0;
1759

1760
		opts.no_divider = 1;
1761

1762
		if (*arg == ':') {
1763
			arg++;
1764
			if (format_set_trailers_options(&opts, &filter_list, &sepbuf, &kvsepbuf, &arg, NULL))
1765
				goto trailer_out;
1766
		}
1767
		if (*arg == ')') {
1768
			format_trailers_from_commit(&opts, msg + c->subject_off, sb);
1769
			ret = arg - placeholder + 1;
1770
		}
1771
	trailer_out:
1772
		string_list_clear(&filter_list, 0);
1773
		strbuf_release(&sepbuf);
1774
		return ret;
1775
	}
1776

1777
	return 0;	/* unknown placeholder */
1778
}
1779

1780
static size_t format_and_pad_commit(struct strbuf *sb, /* in UTF-8 */
1781
				    const char *placeholder,
1782
				    struct format_commit_context *c)
1783
{
1784
	struct strbuf local_sb = STRBUF_INIT;
1785
	size_t total_consumed = 0;
1786
	int len, padding = c->padding;
1787

1788
	if (padding < 0) {
1789
		const char *start = strrchr(sb->buf, '\n');
1790
		int occupied;
1791
		if (!start)
1792
			start = sb->buf;
1793
		occupied = utf8_strnwidth(start, strlen(start), 1);
1794
		occupied += c->pretty_ctx->graph_width;
1795
		padding = (-padding) - occupied;
1796
	}
1797
	while (1) {
1798
		int modifier = *placeholder == 'C';
1799
		size_t consumed = format_commit_one(&local_sb, placeholder, c);
1800
		total_consumed += consumed;
1801

1802
		if (!modifier)
1803
			break;
1804

1805
		placeholder += consumed;
1806
		if (*placeholder != '%')
1807
			break;
1808
		placeholder++;
1809
		total_consumed++;
1810
	}
1811
	len = utf8_strnwidth(local_sb.buf, local_sb.len, 1);
1812

1813
	if (c->flush_type == flush_left_and_steal) {
1814
		const char *ch = sb->buf + sb->len - 1;
1815
		while (len > padding && ch > sb->buf) {
1816
			const char *p;
1817
			if (*ch == ' ') {
1818
				ch--;
1819
				padding++;
1820
				continue;
1821
			}
1822
			/* check for trailing ansi sequences */
1823
			if (*ch != 'm')
1824
				break;
1825
			p = ch - 1;
1826
			while (p > sb->buf && ch - p < 10 && *p != '\033')
1827
				p--;
1828
			if (*p != '\033' ||
1829
			    ch + 1 - p != display_mode_esc_sequence_len(p))
1830
				break;
1831
			/*
1832
			 * got a good ansi sequence, put it back to
1833
			 * local_sb as we're cutting sb
1834
			 */
1835
			strbuf_insert(&local_sb, 0, p, ch + 1 - p);
1836
			ch = p - 1;
1837
		}
1838
		strbuf_setlen(sb, ch + 1 - sb->buf);
1839
		c->flush_type = flush_left;
1840
	}
1841

1842
	if (len > padding) {
1843
		switch (c->truncate) {
1844
		case trunc_left:
1845
			strbuf_utf8_replace(&local_sb,
1846
					    0, len - (padding - 2),
1847
					    "..");
1848
			break;
1849
		case trunc_middle:
1850
			strbuf_utf8_replace(&local_sb,
1851
					    padding / 2 - 1,
1852
					    len - (padding - 2),
1853
					    "..");
1854
			break;
1855
		case trunc_right:
1856
			strbuf_utf8_replace(&local_sb,
1857
					    padding - 2, len - (padding - 2),
1858
					    "..");
1859
			break;
1860
		case trunc_none:
1861
			break;
1862
		}
1863
		strbuf_addbuf(sb, &local_sb);
1864
	} else {
1865
		size_t sb_len = sb->len, offset = 0;
1866
		if (c->flush_type == flush_left)
1867
			offset = padding - len;
1868
		else if (c->flush_type == flush_both)
1869
			offset = (padding - len) / 2;
1870
		/*
1871
		 * we calculate padding in columns, now
1872
		 * convert it back to chars
1873
		 */
1874
		padding = padding - len + local_sb.len;
1875
		strbuf_addchars(sb, ' ', padding);
1876
		memcpy(sb->buf + sb_len + offset, local_sb.buf,
1877
		       local_sb.len);
1878
	}
1879
	strbuf_release(&local_sb);
1880
	c->flush_type = no_flush;
1881
	return total_consumed;
1882
}
1883

1884
static size_t format_commit_item(struct strbuf *sb, /* in UTF-8 */
1885
				 const char *placeholder,
1886
				 struct format_commit_context *context)
1887
{
1888
	size_t consumed, orig_len;
1889
	enum {
1890
		NO_MAGIC,
1891
		ADD_LF_BEFORE_NON_EMPTY,
1892
		DEL_LF_BEFORE_EMPTY,
1893
		ADD_SP_BEFORE_NON_EMPTY
1894
	} magic = NO_MAGIC;
1895

1896
	switch (placeholder[0]) {
1897
	case '-':
1898
		magic = DEL_LF_BEFORE_EMPTY;
1899
		break;
1900
	case '+':
1901
		magic = ADD_LF_BEFORE_NON_EMPTY;
1902
		break;
1903
	case ' ':
1904
		magic = ADD_SP_BEFORE_NON_EMPTY;
1905
		break;
1906
	default:
1907
		break;
1908
	}
1909
	if (magic != NO_MAGIC) {
1910
		placeholder++;
1911

1912
		switch (placeholder[0]) {
1913
		case 'w':
1914
			/*
1915
			 * `%+w()` cannot ever expand to a non-empty string,
1916
			 * and it potentially changes the layout of preceding
1917
			 * contents. We're thus not able to handle the magic in
1918
			 * this combination and refuse the pattern.
1919
			 */
1920
			return 0;
1921
		};
1922
	}
1923

1924
	orig_len = sb->len;
1925
	if (context->flush_type == no_flush)
1926
		consumed = format_commit_one(sb, placeholder, context);
1927
	else
1928
		consumed = format_and_pad_commit(sb, placeholder, context);
1929
	if (magic == NO_MAGIC)
1930
		return consumed;
1931

1932
	if ((orig_len == sb->len) && magic == DEL_LF_BEFORE_EMPTY) {
1933
		while (sb->len && sb->buf[sb->len - 1] == '\n')
1934
			strbuf_setlen(sb, sb->len - 1);
1935
	} else if (orig_len != sb->len) {
1936
		if (magic == ADD_LF_BEFORE_NON_EMPTY)
1937
			strbuf_insertstr(sb, orig_len, "\n");
1938
		else if (magic == ADD_SP_BEFORE_NON_EMPTY)
1939
			strbuf_insertstr(sb, orig_len, " ");
1940
	}
1941
	return consumed + 1;
1942
}
1943

1944
void userformat_find_requirements(const char *fmt, struct userformat_want *w)
1945
{
1946
	if (!fmt) {
1947
		if (!user_format)
1948
			return;
1949
		fmt = user_format;
1950
	}
1951
	while ((fmt = strchr(fmt, '%'))) {
1952
		fmt++;
1953
		if (skip_prefix(fmt, "%", &fmt))
1954
			continue;
1955

1956
		if (*fmt == '+' || *fmt == '-' || *fmt == ' ')
1957
			fmt++;
1958

1959
		switch (*fmt) {
1960
		case 'N':
1961
			w->notes = 1;
1962
			break;
1963
		case 'S':
1964
			w->source = 1;
1965
			break;
1966
		case 'd':
1967
		case 'D':
1968
			w->decorate = 1;
1969
			break;
1970
		case '(':
1971
			if (starts_with(fmt + 1, "decorate"))
1972
				w->decorate = 1;
1973
			break;
1974
		}
1975
	}
1976
}
1977

1978
void repo_format_commit_message(struct repository *r,
1979
				const struct commit *commit,
1980
				const char *format, struct strbuf *sb,
1981
				const struct pretty_print_context *pretty_ctx)
1982
{
1983
	struct format_commit_context context = {
1984
		.repository = r,
1985
		.commit = commit,
1986
		.pretty_ctx = pretty_ctx,
1987
		.wrap_start = sb->len
1988
	};
1989
	const char *output_enc = pretty_ctx->output_encoding;
1990
	const char *utf8 = "UTF-8";
1991

1992
	while (strbuf_expand_step(sb, &format)) {
1993
		size_t len;
1994

1995
		if (skip_prefix(format, "%", &format))
1996
			strbuf_addch(sb, '%');
1997
		else if ((len = format_commit_item(sb, format, &context)))
1998
			format += len;
1999
		else
2000
			strbuf_addch(sb, '%');
2001
	}
2002
	rewrap_message_tail(sb, &context, 0, 0, 0);
2003

2004
	/*
2005
	 * Convert output to an actual output encoding; note that
2006
	 * format_commit_item() will always use UTF-8, so we don't
2007
	 * have to bother if that's what the output wants.
2008
	 */
2009
	if (output_enc) {
2010
		if (same_encoding(utf8, output_enc))
2011
			output_enc = NULL;
2012
	} else {
2013
		if (context.commit_encoding &&
2014
		    !same_encoding(context.commit_encoding, utf8))
2015
			output_enc = context.commit_encoding;
2016
	}
2017

2018
	if (output_enc) {
2019
		size_t outsz;
2020
		char *out = reencode_string_len(sb->buf, sb->len,
2021
						output_enc, utf8, &outsz);
2022
		if (out)
2023
			strbuf_attach(sb, out, outsz, outsz + 1);
2024
	}
2025

2026
	free(context.commit_encoding);
2027
	repo_unuse_commit_buffer(r, commit, context.message);
2028
}
2029

2030
static void pp_header(struct pretty_print_context *pp,
2031
		      const char *encoding,
2032
		      const struct commit *commit,
2033
		      const char **msg_p,
2034
		      struct strbuf *sb)
2035
{
2036
	int parents_shown = 0;
2037

2038
	for (;;) {
2039
		const char *name, *line = *msg_p;
2040
		int linelen = get_one_line(*msg_p);
2041

2042
		if (!linelen)
2043
			return;
2044
		*msg_p += linelen;
2045

2046
		if (linelen == 1)
2047
			/* End of header */
2048
			return;
2049

2050
		if (pp->fmt == CMIT_FMT_RAW) {
2051
			strbuf_add(sb, line, linelen);
2052
			continue;
2053
		}
2054

2055
		if (starts_with(line, "parent ")) {
2056
			if (linelen != the_hash_algo->hexsz + 8)
2057
				die("bad parent line in commit");
2058
			continue;
2059
		}
2060

2061
		if (!parents_shown) {
2062
			unsigned num = commit_list_count(commit->parents);
2063
			/* with enough slop */
2064
			strbuf_grow(sb, num * (GIT_MAX_HEXSZ + 10) + 20);
2065
			add_merge_info(pp, sb, commit);
2066
			parents_shown = 1;
2067
		}
2068

2069
		/*
2070
		 * MEDIUM == DEFAULT shows only author with dates.
2071
		 * FULL shows both authors but not dates.
2072
		 * FULLER shows both authors and dates.
2073
		 */
2074
		if (skip_prefix(line, "author ", &name)) {
2075
			strbuf_grow(sb, linelen + 80);
2076
			pp_user_info(pp, "Author", sb, name, encoding);
2077
		}
2078
		if (skip_prefix(line, "committer ", &name) &&
2079
		    (pp->fmt == CMIT_FMT_FULL || pp->fmt == CMIT_FMT_FULLER)) {
2080
			strbuf_grow(sb, linelen + 80);
2081
			pp_user_info(pp, "Commit", sb, name, encoding);
2082
		}
2083
	}
2084
}
2085

2086
void pp_email_subject(struct pretty_print_context *pp,
2087
		      const char **msg_p,
2088
		      struct strbuf *sb,
2089
		      const char *encoding,
2090
		      int need_8bit_cte)
2091
{
2092
	static const int max_length = 78; /* per rfc2047 */
2093
	struct strbuf title;
2094

2095
	strbuf_init(&title, 80);
2096
	*msg_p = format_subject(&title, *msg_p,
2097
				pp->preserve_subject ? "\n" : " ");
2098

2099
	strbuf_grow(sb, title.len + 1024);
2100
	fmt_output_email_subject(sb, pp->rev);
2101
	if (pp->encode_email_headers &&
2102
	    needs_rfc2047_encoding(title.buf, title.len))
2103
		add_rfc2047(sb, title.buf, title.len,
2104
			    encoding, RFC2047_SUBJECT);
2105
	else
2106
		strbuf_add_wrapped_bytes(sb, title.buf, title.len,
2107
					 -last_line_length(sb), 1, max_length);
2108
	strbuf_addch(sb, '\n');
2109

2110
	if (need_8bit_cte == 0) {
2111
		int i;
2112
		for (i = 0; i < pp->in_body_headers.nr; i++) {
2113
			if (has_non_ascii(pp->in_body_headers.items[i].string)) {
2114
				need_8bit_cte = 1;
2115
				break;
2116
			}
2117
		}
2118
	}
2119

2120
	if (need_8bit_cte > 0) {
2121
		const char *header_fmt =
2122
			"MIME-Version: 1.0\n"
2123
			"Content-Type: text/plain; charset=%s\n"
2124
			"Content-Transfer-Encoding: 8bit\n";
2125
		strbuf_addf(sb, header_fmt, encoding);
2126
	}
2127
	if (pp->after_subject) {
2128
		strbuf_addstr(sb, pp->after_subject);
2129
	}
2130

2131
	strbuf_addch(sb, '\n');
2132

2133
	if (pp->in_body_headers.nr) {
2134
		int i;
2135
		for (i = 0; i < pp->in_body_headers.nr; i++) {
2136
			strbuf_addstr(sb, pp->in_body_headers.items[i].string);
2137
			free(pp->in_body_headers.items[i].string);
2138
		}
2139
		string_list_clear(&pp->in_body_headers, 0);
2140
		strbuf_addch(sb, '\n');
2141
	}
2142

2143
	strbuf_release(&title);
2144
}
2145

2146
static int pp_utf8_width(const char *start, const char *end)
2147
{
2148
	int width = 0;
2149
	size_t remain = end - start;
2150

2151
	while (remain) {
2152
		int n = utf8_width(&start, &remain);
2153
		if (n < 0 || !start)
2154
			return -1;
2155
		width += n;
2156
	}
2157
	return width;
2158
}
2159

2160
static void strbuf_add_tabexpand(struct strbuf *sb, struct grep_opt *opt,
2161
				 int color, int tabwidth, const char *line,
2162
				 int linelen)
2163
{
2164
	const char *tab;
2165

2166
	while ((tab = memchr(line, '\t', linelen)) != NULL) {
2167
		int width = pp_utf8_width(line, tab);
2168

2169
		/*
2170
		 * If it wasn't well-formed utf8, or it
2171
		 * had characters with badly defined
2172
		 * width (control characters etc), just
2173
		 * give up on trying to align things.
2174
		 */
2175
		if (width < 0)
2176
			break;
2177

2178
		/* Output the data .. */
2179
		append_line_with_color(sb, opt, line, tab - line, color,
2180
				       GREP_CONTEXT_BODY,
2181
				       GREP_HEADER_FIELD_MAX);
2182

2183
		/* .. and the de-tabified tab */
2184
		strbuf_addchars(sb, ' ', tabwidth - (width % tabwidth));
2185

2186
		/* Skip over the printed part .. */
2187
		linelen -= tab + 1 - line;
2188
		line = tab + 1;
2189
	}
2190

2191
	/*
2192
	 * Print out everything after the last tab without
2193
	 * worrying about width - there's nothing more to
2194
	 * align.
2195
	 */
2196
	append_line_with_color(sb, opt, line, linelen, color, GREP_CONTEXT_BODY,
2197
			       GREP_HEADER_FIELD_MAX);
2198
}
2199

2200
/*
2201
 * pp_handle_indent() prints out the intendation, and
2202
 * the whole line (without the final newline), after
2203
 * de-tabifying.
2204
 */
2205
static void pp_handle_indent(struct pretty_print_context *pp,
2206
			     struct strbuf *sb, int indent,
2207
			     const char *line, int linelen)
2208
{
2209
	struct grep_opt *opt = pp->rev ? &pp->rev->grep_filter : NULL;
2210

2211
	strbuf_addchars(sb, ' ', indent);
2212
	if (pp->expand_tabs_in_log)
2213
		strbuf_add_tabexpand(sb, opt, pp->color, pp->expand_tabs_in_log,
2214
				     line, linelen);
2215
	else
2216
		append_line_with_color(sb, opt, line, linelen, pp->color,
2217
				       GREP_CONTEXT_BODY,
2218
				       GREP_HEADER_FIELD_MAX);
2219
}
2220

2221
static int is_mboxrd_from(const char *line, int len)
2222
{
2223
	/*
2224
	 * a line matching /^From $/ here would only have len == 4
2225
	 * at this point because is_empty_line would've trimmed all
2226
	 * trailing space
2227
	 */
2228
	return len > 4 && starts_with(line + strspn(line, ">"), "From ");
2229
}
2230

2231
void pp_remainder(struct pretty_print_context *pp,
2232
		  const char **msg_p,
2233
		  struct strbuf *sb,
2234
		  int indent)
2235
{
2236
	struct grep_opt *opt = pp->rev ? &pp->rev->grep_filter : NULL;
2237
	int first = 1;
2238

2239
	for (;;) {
2240
		const char *line = *msg_p;
2241
		int linelen = get_one_line(line);
2242
		*msg_p += linelen;
2243

2244
		if (!linelen)
2245
			break;
2246

2247
		if (is_blank_line(line, &linelen)) {
2248
			if (first)
2249
				continue;
2250
			if (pp->fmt == CMIT_FMT_SHORT)
2251
				break;
2252
		}
2253
		first = 0;
2254

2255
		strbuf_grow(sb, linelen + indent + 20);
2256
		if (indent)
2257
			pp_handle_indent(pp, sb, indent, line, linelen);
2258
		else if (pp->expand_tabs_in_log)
2259
			strbuf_add_tabexpand(sb, opt, pp->color,
2260
					     pp->expand_tabs_in_log, line,
2261
					     linelen);
2262
		else {
2263
			if (pp->fmt == CMIT_FMT_MBOXRD &&
2264
					is_mboxrd_from(line, linelen))
2265
				strbuf_addch(sb, '>');
2266

2267
			append_line_with_color(sb, opt, line, linelen,
2268
					       pp->color, GREP_CONTEXT_BODY,
2269
					       GREP_HEADER_FIELD_MAX);
2270
		}
2271
		strbuf_addch(sb, '\n');
2272
	}
2273
}
2274

2275
void pretty_print_commit(struct pretty_print_context *pp,
2276
			 const struct commit *commit,
2277
			 struct strbuf *sb)
2278
{
2279
	unsigned long beginning_of_body;
2280
	int indent = 4;
2281
	const char *msg;
2282
	const char *reencoded;
2283
	const char *encoding;
2284
	int need_8bit_cte = pp->need_8bit_cte;
2285

2286
	if (pp->fmt == CMIT_FMT_USERFORMAT) {
2287
		repo_format_commit_message(the_repository, commit,
2288
					   user_format, sb, pp);
2289
		return;
2290
	}
2291

2292
	encoding = get_log_output_encoding();
2293
	msg = reencoded = repo_logmsg_reencode(the_repository, commit, NULL,
2294
					       encoding);
2295

2296
	if (pp->fmt == CMIT_FMT_ONELINE || cmit_fmt_is_mail(pp->fmt))
2297
		indent = 0;
2298

2299
	/*
2300
	 * We need to check and emit Content-type: to mark it
2301
	 * as 8-bit if we haven't done so.
2302
	 */
2303
	if (cmit_fmt_is_mail(pp->fmt) && need_8bit_cte == 0) {
2304
		int i, ch, in_body;
2305

2306
		for (in_body = i = 0; (ch = msg[i]); i++) {
2307
			if (!in_body) {
2308
				/* author could be non 7-bit ASCII but
2309
				 * the log may be so; skip over the
2310
				 * header part first.
2311
				 */
2312
				if (ch == '\n' && msg[i+1] == '\n')
2313
					in_body = 1;
2314
			}
2315
			else if (non_ascii(ch)) {
2316
				need_8bit_cte = 1;
2317
				break;
2318
			}
2319
		}
2320
	}
2321

2322
	pp_header(pp, encoding, commit, &msg, sb);
2323
	if (pp->fmt != CMIT_FMT_ONELINE && !cmit_fmt_is_mail(pp->fmt)) {
2324
		strbuf_addch(sb, '\n');
2325
	}
2326

2327
	/* Skip excess blank lines at the beginning of body, if any... */
2328
	msg = skip_blank_lines(msg);
2329

2330
	/* These formats treat the title line specially. */
2331
	if (pp->fmt == CMIT_FMT_ONELINE) {
2332
		msg = format_subject(sb, msg, " ");
2333
		strbuf_addch(sb, '\n');
2334
	} else if (cmit_fmt_is_mail(pp->fmt))
2335
		pp_email_subject(pp, &msg, sb, encoding, need_8bit_cte);
2336

2337
	beginning_of_body = sb->len;
2338
	if (pp->fmt != CMIT_FMT_ONELINE)
2339
		pp_remainder(pp, &msg, sb, indent);
2340
	strbuf_rtrim(sb);
2341

2342
	/* Make sure there is an EOLN for the non-oneline case */
2343
	if (pp->fmt != CMIT_FMT_ONELINE)
2344
		strbuf_addch(sb, '\n');
2345

2346
	/*
2347
	 * The caller may append additional body text in e-mail
2348
	 * format.  Make sure we did not strip the blank line
2349
	 * between the header and the body.
2350
	 */
2351
	if (cmit_fmt_is_mail(pp->fmt) && sb->len <= beginning_of_body)
2352
		strbuf_addch(sb, '\n');
2353

2354
	repo_unuse_commit_buffer(the_repository, commit, reencoded);
2355
}
2356

2357
void pp_commit_easy(enum cmit_fmt fmt, const struct commit *commit,
2358
		    struct strbuf *sb)
2359
{
2360
	struct pretty_print_context pp = {0};
2361
	pp.fmt = fmt;
2362
	pretty_print_commit(&pp, commit, sb);
2363
}
2364