?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
hex: drop sha1_to_hex_r()
[git.git] / pretty.c
blob93eb6e837071a3e54437a92c0e2338e1ce1ef6f4
1 #include "cache.h"
2 #include "config.h"
3 #include "commit.h"
4 #include "utf8.h"
5 #include "diff.h"
6 #include "revision.h"
7 #include "string-list.h"
8 #include "mailmap.h"
9 #include "log-tree.h"
10 #include "notes.h"
11 #include "color.h"
12 #include "reflog-walk.h"
13 #include "gpg-interface.h"
14 #include "trailer.h"
15
16 static char *user_format;
17 static struct cmt_fmt_map {
18 const char *name;
19 enum cmit_fmt format;
20 int is_tformat;
21 int expand_tabs_in_log;
22 int is_alias;
23 const char *user_format;
24 } *commit_formats;
25 static size_t builtin_formats_len;
26 static size_t commit_formats_len;
27 static size_t commit_formats_alloc;
28 static struct cmt_fmt_map *find_commit_format(const char *sought);
29
30 int commit_format_is_empty(enum cmit_fmt fmt)
31 {
32 return fmt == CMIT_FMT_USERFORMAT && !*user_format;
33 }
34
35 static 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
44 static int git_pretty_formats_config(const char *var, const char *value, void *cb)
45 {
46 struct cmt_fmt_map *commit_format = NULL;
47 const char *name;
48 const char *fmt;
49 int i;
50
51 if (!skip_prefix(var, "pretty.", &name))
52 return 0;
53
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];
70 memset(commit_format, 0, sizeof(*commit_format));
71 commit_formats_len++;
72 }
73
74 commit_format->name = xstrdup(name);
75 commit_format->format = CMIT_FMT_USERFORMAT;
76 if (git_config_string(&fmt, var, value))
77 return -1;
78
79 if (skip_prefix(fmt, "format:", &fmt))
80 commit_format->is_tformat = 0;
81 else if (skip_prefix(fmt, "tformat:", &fmt) || strchr(fmt, '%'))
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
90 static void setup_commit_formats(void)
91 {
92 struct cmt_fmt_map builtin_formats[] = {
93 { "raw", CMIT_FMT_RAW, 0, 0 },
94 { "medium", CMIT_FMT_MEDIUM, 0, 8 },
95 { "short", CMIT_FMT_SHORT, 0, 0 },
96 { "email", CMIT_FMT_EMAIL, 0, 0 },
97 { "mboxrd", CMIT_FMT_MBOXRD, 0, 0 },
98 { "fuller", CMIT_FMT_FULLER, 0, 8 },
99 { "full", CMIT_FMT_FULL, 0, 8 },
100 { "oneline", CMIT_FMT_ONELINE, 1, 0 }
101 /*
102 * Please update $__git_log_pretty_formats in
103 * git-completion.bash when you add new formats.
104 */
105 };
106 commit_formats_len = ARRAY_SIZE(builtin_formats);
107 builtin_formats_len = commit_formats_len;
108 ALLOC_GROW(commit_formats, commit_formats_len, commit_formats_alloc);
109 COPY_ARRAY(commit_formats, builtin_formats,
110 ARRAY_SIZE(builtin_formats));
111
112 git_config(git_pretty_formats_config, NULL);
113 }
114
115 static struct cmt_fmt_map *find_commit_format_recursive(const char *sought,
116 const char *original,
117 int num_redirections)
118 {
119 struct cmt_fmt_map *found = NULL;
120 size_t found_match_len = 0;
121 int i;
122
123 if (num_redirections >= commit_formats_len)
124 die("invalid --pretty format: "
125 "'%s' references an alias which points to itself",
126 original);
127
128 for (i = 0; i < commit_formats_len; i++) {
129 size_t match_len;
130
131 if (!starts_with(commit_formats[i].name, sought))
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 }
140
141 if (found && found->is_alias) {
142 found = find_commit_format_recursive(found->user_format,
143 original,
144 num_redirections+1);
145 }
146
147 return found;
148 }
149
150 static 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
158 void get_commit_format(const char *arg, struct rev_info *rev)
159 {
160 struct cmt_fmt_map *commit_format;
161
162 rev->use_terminator = 0;
163 if (!arg) {
164 rev->commit_format = CMIT_FMT_DEFAULT;
165 return;
166 }
167 if (skip_prefix(arg, "format:", &arg)) {
168 save_user_format(rev, arg, 0);
169 return;
170 }
171
172 if (!*arg || skip_prefix(arg, "tformat:", &arg) || strchr(arg, '%')) {
173 save_user_format(rev, arg, 1);
174 return;
175 }
176
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;
183 rev->expand_tabs_in_log_default = commit_format->expand_tabs_in_log;
184 if (commit_format->format == CMIT_FMT_USERFORMAT) {
185 save_user_format(rev, commit_format->user_format,
186 commit_format->is_tformat);
187 }
188 }
189
190 /*
191 * Generic support for pretty-printing the header
192 */
193 static 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 */
209 static int non_ascii(int ch)
210 {
211 return !isascii(ch) || ch == '\033';
212 }
213
214 int 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
226 static 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
248 static int needs_rfc822_quoting(const char *s, int len)
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
257 static 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
268 static 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
289 enum rfc2047_type {
290 RFC2047_SUBJECT,
291 RFC2047_ADDRESS
292 };
293
294 static int is_rfc2047_special(char ch, enum rfc2047_type type)
295 {
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 == '_')
320 return 1;
321
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 == '/');
344 }
345
346 static int needs_rfc2047_encoding(const char *line, int len)
347 {
348 int i;
349
350 for (i = 0; i < len; i++) {
351 int ch = line[i];
352 if (non_ascii(ch) || ch == '\n')
353 return 1;
354 if ((i + 1 < len) && (ch == '=' && line[i+1] == '?'))
355 return 1;
356 }
357
358 return 0;
359 }
360
361 static void add_rfc2047(struct strbuf *sb, const char *line, size_t len,
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
368 strbuf_grow(sb, len * 3 + strlen(encoding) + 100);
369 strbuf_addf(sb, "=?%s?q?", encoding);
370 line_len += strlen(encoding) + 5; /* 5 for =??q? */
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;
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 */
395
396 if (line_len + encoded_len + 2 > max_encoded_length) {
397 /* It won't fit with trailing "?=" --- break the line */
398 strbuf_addf(sb, "?=\n =?%s?q?", encoding);
399 line_len = strlen(encoding) + 5 + 1; /* =??q? plus SP */
400 }
401
402 for (i = 0; i < chrlen; i++)
403 strbuf_addf(sb, encoded_fmt, p[i]);
404 line_len += encoded_len;
405 }
406 strbuf_addstr(sb, "?=");
407 }
408
409 const char *show_ident_date(const struct ident_split *ident,
410 const struct date_mode *mode)
411 {
412 timestamp_t date = 0;
413 long tz = 0;
414
415 if (ident->date_begin && ident->date_end)
416 date = parse_timestamp(ident->date_begin, NULL, 10);
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);
422 if (tz >= INT_MAX || tz <= INT_MIN)
423 tz = 0;
424 }
425 return show_date(date, tz, mode);
426 }
427
428 void pp_user_info(struct pretty_print_context *pp,
429 const char *what, struct strbuf *sb,
430 const char *line, const char *encoding)
431 {
432 struct ident_split ident;
433 char *line_end;
434 const char *mailbuf, *namebuf;
435 size_t namelen, maillen;
436 int max_length = 78; /* per rfc2822 */
437
438 if (pp->fmt == CMIT_FMT_ONELINE)
439 return;
440
441 line_end = strchrnul(line, '\n');
442 if (split_ident_line(&ident, line, line_end - line))
443 return;
444
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
453 if (cmit_fmt_is_mail(pp->fmt)) {
454 if (pp->from_ident && ident_cmp(pp->from_ident, &ident)) {
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
471 strbuf_addstr(sb, "From: ");
472 if (needs_rfc2047_encoding(namebuf, namelen)) {
473 add_rfc2047(sb, namebuf, namelen,
474 encoding, RFC2047_ADDRESS);
475 max_length = 76; /* per rfc2047 */
476 } else if (needs_rfc822_quoting(namebuf, namelen)) {
477 struct strbuf quoted = STRBUF_INIT;
478 add_rfc822_quoted(&quoted, namebuf, namelen);
479 strbuf_add_wrapped_bytes(sb, quoted.buf, quoted.len,
480 -6, 1, max_length);
481 strbuf_release(&quoted);
482 } else {
483 strbuf_add_wrapped_bytes(sb, namebuf, namelen,
484 -6, 1, max_length);
485 }
486
487 if (max_length <
488 last_line_length(sb) + strlen(" <") + maillen + strlen(">"))
489 strbuf_addch(sb, '\n');
490 strbuf_addf(sb, " <%.*s>\n", (int)maillen, mailbuf);
491 } else {
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);
495 }
496
497 switch (pp->fmt) {
498 case CMIT_FMT_MEDIUM:
499 strbuf_addf(sb, "Date: %s\n",
500 show_ident_date(&ident, &pp->date_mode));
501 break;
502 case CMIT_FMT_EMAIL:
503 case CMIT_FMT_MBOXRD:
504 strbuf_addf(sb, "Date: %s\n",
505 show_ident_date(&ident, DATE_MODE(RFC2822)));
506 break;
507 case CMIT_FMT_FULLER:
508 strbuf_addf(sb, "%sDate: %s\n", what,
509 show_ident_date(&ident, &pp->date_mode));
510 break;
511 default:
512 /* notin' */
513 break;
514 }
515 }
516
517 static int is_blank_line(const char *line, int *len_p)
518 {
519 int len = *len_p;
520 while (len && isspace(line[len - 1]))
521 len--;
522 *len_p = len;
523 return !len;
524 }
525
526 const char *skip_blank_lines(const char *msg)
527 {
528 for (;;) {
529 int linelen = get_one_line(msg);
530 int ll = linelen;
531 if (!linelen)
532 break;
533 if (!is_blank_line(msg, &ll))
534 break;
535 msg += linelen;
536 }
537 return msg;
538 }
539
540 static void add_merge_info(const struct pretty_print_context *pp,
541 struct strbuf *sb, const struct commit *commit)
542 {
543 struct commit_list *parent = commit->parents;
544
545 if ((pp->fmt == CMIT_FMT_ONELINE) || (cmit_fmt_is_mail(pp->fmt)) ||
546 !parent || !parent->next)
547 return;
548
549 strbuf_addstr(sb, "Merge:");
550
551 while (parent) {
552 struct object_id *oidp = &parent->item->object.oid;
553 strbuf_addch(sb, ' ');
554 if (pp->abbrev)
555 strbuf_add_unique_abbrev(sb, oidp, pp->abbrev);
556 else
557 strbuf_addstr(sb, oid_to_hex(oidp));
558 parent = parent->next;
559 }
560 strbuf_addch(sb, '\n');
561 }
562
563 static char *get_header(const char *msg, const char *key)
564 {
565 size_t len;
566 const char *v = find_commit_header(msg, key, &len);
567 return v ? xmemdupz(v, len) : NULL;
568 }
569
570 static char *replace_encoding_header(char *buf, const char *encoding)
571 {
572 struct strbuf tmp = STRBUF_INIT;
573 size_t start, len;
574 char *cp = buf;
575
576 /* guess if there is an encoding header before a \n\n */
577 while (!starts_with(cp, "encoding ")) {
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
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
601 const char *repo_logmsg_reencode(struct repository *r,
602 const struct commit *commit,
603 char **commit_encoding,
604 const char *output_encoding)
605 {
606 static const char *utf8 = "UTF-8";
607 const char *use_encoding;
608 char *encoding;
609 const char *msg = repo_get_commit_buffer(r, commit, NULL);
610 char *out;
611
612 if (!output_encoding || !*output_encoding) {
613 if (commit_encoding)
614 *commit_encoding = get_header(msg, "encoding");
615 return msg;
616 }
617 encoding = get_header(msg, "encoding");
618 if (commit_encoding)
619 *commit_encoding = encoding;
620 use_encoding = encoding ? encoding : utf8;
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
634 * the cached copy from get_commit_buffer, we need to duplicate it
635 * to avoid munging the cached copy.
636 */
637 if (msg == get_cached_commit_buffer(r, commit, NULL))
638 out = xstrdup(msg);
639 else
640 out = (char *)msg;
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);
650 if (out)
651 repo_unuse_commit_buffer(r, commit, msg);
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 */
658 if (out)
659 out = replace_encoding_header(out, output_encoding);
660
661 if (!commit_encoding)
662 free(encoding);
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
670 static int mailmap_name(const char **email, size_t *email_len,
671 const char **name, size_t *name_len)
672 {
673 static struct string_list *mail_map;
674 if (!mail_map) {
675 mail_map = xcalloc(1, sizeof(*mail_map));
676 read_mailmap(mail_map, NULL);
677 }
678 return mail_map->nr && map_user(mail_map, email, email_len, name, name_len);
679 }
680
681 static size_t format_person_part(struct strbuf *sb, char part,
682 const char *msg, int len,
683 const struct date_mode *dmode)
684 {
685 /* currently all placeholders have same length */
686 const int placeholder_len = 2;
687 struct ident_split s;
688 const char *name, *mail;
689 size_t maillen, namelen;
690
691 if (split_ident_line(&s, msg, len) < 0)
692 goto skip;
693
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' || part == 'L') /* mailmap lookup */
700 mailmap_name(&mail, &maillen, &name, &namelen);
701 if (part == 'n' || part == 'N') { /* name */
702 strbuf_add(sb, name, namelen);
703 return placeholder_len;
704 }
705 if (part == 'e' || part == 'E') { /* email */
706 strbuf_add(sb, mail, maillen);
707 return placeholder_len;
708 }
709 if (part == 'l' || part == 'L') { /* local-part */
710 const char *at = memchr(mail, '@', maillen);
711 if (at)
712 maillen = at - mail;
713 strbuf_add(sb, mail, maillen);
714 return placeholder_len;
715 }
716
717 if (!s.date_begin)
718 goto skip;
719
720 if (part == 't') { /* date, UNIX timestamp */
721 strbuf_add(sb, s.date_begin, s.date_end - s.date_begin);
722 return placeholder_len;
723 }
724
725 switch (part) {
726 case 'd': /* date */
727 strbuf_addstr(sb, show_ident_date(&s, dmode));
728 return placeholder_len;
729 case 'D': /* date, RFC2822 style */
730 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(RFC2822)));
731 return placeholder_len;
732 case 'r': /* date, relative */
733 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(RELATIVE)));
734 return placeholder_len;
735 case 'i': /* date, ISO 8601-like */
736 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(ISO8601)));
737 return placeholder_len;
738 case 'I': /* date, ISO 8601 strict */
739 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(ISO8601_STRICT)));
740 return placeholder_len;
741 }
742
743 skip:
744 /*
745 * reading from either a bogus commit, or a reflog entry with
746 * %gn, %ge, etc.; 'sb' cannot be updated, but we still need
747 * to compute a valid return value.
748 */
749 if (part == 'n' || part == 'e' || part == 't' || part == 'd'
750 || part == 'D' || part == 'r' || part == 'i')
751 return placeholder_len;
752
753 return 0; /* unknown placeholder */
754 }
755
756 struct chunk {
757 size_t off;
758 size_t len;
759 };
760
761 enum flush_type {
762 no_flush,
763 flush_right,
764 flush_left,
765 flush_left_and_steal,
766 flush_both
767 };
768
769 enum trunc_type {
770 trunc_none,
771 trunc_left,
772 trunc_middle,
773 trunc_right
774 };
775
776 struct format_commit_context {
777 const struct commit *commit;
778 const struct pretty_print_context *pretty_ctx;
779 unsigned commit_header_parsed:1;
780 unsigned commit_message_parsed:1;
781 struct signature_check signature_check;
782 enum flush_type flush_type;
783 enum trunc_type truncate;
784 const char *message;
785 char *commit_encoding;
786 size_t width, indent1, indent2;
787 int auto_color;
788 int padding;
789
790 /* These offsets are relative to the start of the commit message. */
791 struct chunk author;
792 struct chunk committer;
793 size_t message_off;
794 size_t subject_off;
795 size_t body_off;
796
797 /* The following ones are relative to the result struct strbuf. */
798 size_t wrap_start;
799 };
800
801 static void parse_commit_header(struct format_commit_context *context)
802 {
803 const char *msg = context->message;
804 int i;
805
806 for (i = 0; msg[i]; i++) {
807 const char *name;
808 int eol;
809 for (eol = i; msg[eol] && msg[eol] != '\n'; eol++)
810 ; /* do nothing */
811
812 if (i == eol) {
813 break;
814 } else if (skip_prefix(msg + i, "author ", &name)) {
815 context->author.off = name - msg;
816 context->author.len = msg + eol - name;
817 } else if (skip_prefix(msg + i, "committer ", &name)) {
818 context->committer.off = name - msg;
819 context->committer.len = msg + eol - name;
820 }
821 i = eol;
822 }
823 context->message_off = i;
824 context->commit_header_parsed = 1;
825 }
826
827 static int istitlechar(char c)
828 {
829 return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
830 (c >= '0' && c <= '9') || c == '.' || c == '_';
831 }
832
833 static void format_sanitized_subject(struct strbuf *sb, const char *msg)
834 {
835 size_t trimlen;
836 size_t start_len = sb->len;
837 int space = 2;
838
839 for (; *msg && *msg != '\n'; msg++) {
840 if (istitlechar(*msg)) {
841 if (space == 1)
842 strbuf_addch(sb, '-');
843 space = 0;
844 strbuf_addch(sb, *msg);
845 if (*msg == '.')
846 while (*(msg+1) == '.')
847 msg++;
848 } else
849 space |= 1;
850 }
851
852 /* trim any trailing '.' or '-' characters */
853 trimlen = 0;
854 while (sb->len - trimlen > start_len &&
855 (sb->buf[sb->len - 1 - trimlen] == '.'
856 || sb->buf[sb->len - 1 - trimlen] == '-'))
857 trimlen++;
858 strbuf_remove(sb, sb->len - trimlen, trimlen);
859 }
860
861 const char *format_subject(struct strbuf *sb, const char *msg,
862 const char *line_separator)
863 {
864 int first = 1;
865
866 for (;;) {
867 const char *line = msg;
868 int linelen = get_one_line(line);
869
870 msg += linelen;
871 if (!linelen || is_blank_line(line, &linelen))
872 break;
873
874 if (!sb)
875 continue;
876 strbuf_grow(sb, linelen + 2);
877 if (!first)
878 strbuf_addstr(sb, line_separator);
879 strbuf_add(sb, line, linelen);
880 first = 0;
881 }
882 return msg;
883 }
884
885 static void parse_commit_message(struct format_commit_context *c)
886 {
887 const char *msg = c->message + c->message_off;
888 const char *start = c->message;
889
890 msg = skip_blank_lines(msg);
891 c->subject_off = msg - start;
892
893 msg = format_subject(NULL, msg, NULL);
894 msg = skip_blank_lines(msg);
895 c->body_off = msg - start;
896
897 c->commit_message_parsed = 1;
898 }
899
900 static void strbuf_wrap(struct strbuf *sb, size_t pos,
901 size_t width, size_t indent1, size_t indent2)
902 {
903 struct strbuf tmp = STRBUF_INIT;
904
905 if (pos)
906 strbuf_add(&tmp, sb->buf, pos);
907 strbuf_add_wrapped_text(&tmp, sb->buf + pos,
908 (int) indent1, (int) indent2, (int) width);
909 strbuf_swap(&tmp, sb);
910 strbuf_release(&tmp);
911 }
912
913 static void rewrap_message_tail(struct strbuf *sb,
914 struct format_commit_context *c,
915 size_t new_width, size_t new_indent1,
916 size_t new_indent2)
917 {
918 if (c->width == new_width && c->indent1 == new_indent1 &&
919 c->indent2 == new_indent2)
920 return;
921 if (c->wrap_start < sb->len)
922 strbuf_wrap(sb, c->wrap_start, c->width, c->indent1, c->indent2);
923 c->wrap_start = sb->len;
924 c->width = new_width;
925 c->indent1 = new_indent1;
926 c->indent2 = new_indent2;
927 }
928
929 static int format_reflog_person(struct strbuf *sb,
930 char part,
931 struct reflog_walk_info *log,
932 const struct date_mode *dmode)
933 {
934 const char *ident;
935
936 if (!log)
937 return 2;
938
939 ident = get_reflog_ident(log);
940 if (!ident)
941 return 2;
942
943 return format_person_part(sb, part, ident, strlen(ident), dmode);
944 }
945
946 static size_t parse_color(struct strbuf *sb, /* in UTF-8 */
947 const char *placeholder,
948 struct format_commit_context *c)
949 {
950 const char *rest = placeholder;
951 const char *basic_color = NULL;
952
953 if (placeholder[1] == '(') {
954 const char *begin = placeholder + 2;
955 const char *end = strchr(begin, ')');
956 char color[COLOR_MAXLEN];
957
958 if (!end)
959 return 0;
960
961 if (skip_prefix(begin, "auto,", &begin)) {
962 if (!want_color(c->pretty_ctx->color))
963 return end - placeholder + 1;
964 } else if (skip_prefix(begin, "always,", &begin)) {
965 /* nothing to do; we do not respect want_color at all */
966 } else {
967 /* the default is the same as "auto" */
968 if (!want_color(c->pretty_ctx->color))
969 return end - placeholder + 1;
970 }
971
972 if (color_parse_mem(begin, end - begin, color) < 0)
973 die(_("unable to parse --pretty format"));
974 strbuf_addstr(sb, color);
975 return end - placeholder + 1;
976 }
977
978 /*
979 * We handle things like "%C(red)" above; for historical reasons, there
980 * are a few colors that can be specified without parentheses (and
981 * they cannot support things like "auto" or "always" at all).
982 */
983 if (skip_prefix(placeholder + 1, "red", &rest))
984 basic_color = GIT_COLOR_RED;
985 else if (skip_prefix(placeholder + 1, "green", &rest))
986 basic_color = GIT_COLOR_GREEN;
987 else if (skip_prefix(placeholder + 1, "blue", &rest))
988 basic_color = GIT_COLOR_BLUE;
989 else if (skip_prefix(placeholder + 1, "reset", &rest))
990 basic_color = GIT_COLOR_RESET;
991
992 if (basic_color && want_color(c->pretty_ctx->color))
993 strbuf_addstr(sb, basic_color);
994
995 return rest - placeholder;
996 }
997
998 static size_t parse_padding_placeholder(const char *placeholder,
999 struct format_commit_context *c)
1000 {
1001 const char *ch = placeholder;
1002 enum flush_type flush_type;
1003 int to_column = 0;
1004
1005 switch (*ch++) {
1006 case '<':
1007 flush_type = flush_right;
1008 break;
1009 case '>':
1010 if (*ch == '<') {
1011 flush_type = flush_both;
1012 ch++;
1013 } else if (*ch == '>') {
1014 flush_type = flush_left_and_steal;
1015 ch++;
1016 } else
1017 flush_type = flush_left;
1018 break;
1019 default:
1020 return 0;
1021 }
1022
1023 /* the next value means "wide enough to that column" */
1024 if (*ch == '|') {
1025 to_column = 1;
1026 ch++;
1027 }
1028
1029 if (*ch == '(') {
1030 const char *start = ch + 1;
1031 const char *end = start + strcspn(start, ",)");
1032 char *next;
1033 int width;
1034 if (!end || end == start)
1035 return 0;
1036 width = strtol(start, &next, 10);
1037 if (next == start || width == 0)
1038 return 0;
1039 if (width < 0) {
1040 if (to_column)
1041 width += term_columns();
1042 if (width < 0)
1043 return 0;
1044 }
1045 c->padding = to_column ? -width : width;
1046 c->flush_type = flush_type;
1047
1048 if (*end == ',') {
1049 start = end + 1;
1050 end = strchr(start, ')');
1051 if (!end || end == start)
1052 return 0;
1053 if (starts_with(start, "trunc)"))
1054 c->truncate = trunc_right;
1055 else if (starts_with(start, "ltrunc)"))
1056 c->truncate = trunc_left;
1057 else if (starts_with(start, "mtrunc)"))
1058 c->truncate = trunc_middle;
1059 else
1060 return 0;
1061 } else
1062 c->truncate = trunc_none;
1063
1064 return end - placeholder + 1;
1065 }
1066 return 0;
1067 }
1068
1069 static int match_placeholder_arg_value(const char *to_parse, const char *candidate,
1070 const char **end, const char **valuestart,
1071 size_t *valuelen)
1072 {
1073 const char *p;
1074
1075 if (!(skip_prefix(to_parse, candidate, &p)))
1076 return 0;
1077 if (valuestart) {
1078 if (*p == '=') {
1079 *valuestart = p + 1;
1080 *valuelen = strcspn(*valuestart, ",)");
1081 p = *valuestart + *valuelen;
1082 } else {
1083 if (*p != ',' && *p != ')')
1084 return 0;
1085 *valuestart = NULL;
1086 *valuelen = 0;
1087 }
1088 }
1089 if (*p == ',') {
1090 *end = p + 1;
1091 return 1;
1092 }
1093 if (*p == ')') {
1094 *end = p;
1095 return 1;
1096 }
1097 return 0;
1098 }
1099
1100 static int match_placeholder_bool_arg(const char *to_parse, const char *candidate,
1101 const char **end, int *val)
1102 {
1103 const char *argval;
1104 char *strval;
1105 size_t arglen;
1106 int v;
1107
1108 if (!match_placeholder_arg_value(to_parse, candidate, end, &argval, &arglen))
1109 return 0;
1110
1111 if (!argval) {
1112 *val = 1;
1113 return 1;
1114 }
1115
1116 strval = xstrndup(argval, arglen);
1117 v = git_parse_maybe_bool(strval);
1118 free(strval);
1119
1120 if (v == -1)
1121 return 0;
1122
1123 *val = v;
1124
1125 return 1;
1126 }
1127
1128 static int format_trailer_match_cb(const struct strbuf *key, void *ud)
1129 {
1130 const struct string_list *list = ud;
1131 const struct string_list_item *item;
1132
1133 for_each_string_list_item (item, list) {
1134 if (key->len == (uintptr_t)item->util &&
1135 !strncasecmp(item->string, key->buf, key->len))
1136 return 1;
1137 }
1138 return 0;
1139 }
1140
1141 static size_t format_commit_one(struct strbuf *sb, /* in UTF-8 */
1142 const char *placeholder,
1143 void *context)
1144 {
1145 struct format_commit_context *c = context;
1146 const struct commit *commit = c->commit;
1147 const char *msg = c->message;
1148 struct commit_list *p;
1149 const char *arg;
1150 size_t res;
1151 char **slot;
1152
1153 /* these are independent of the commit */
1154 res = strbuf_expand_literal_cb(sb, placeholder, NULL);
1155 if (res)
1156 return res;
1157
1158 switch (placeholder[0]) {
1159 case 'C':
1160 if (starts_with(placeholder + 1, "(auto)")) {
1161 c->auto_color = want_color(c->pretty_ctx->color);
1162 if (c->auto_color && sb->len)
1163 strbuf_addstr(sb, GIT_COLOR_RESET);
1164 return 7; /* consumed 7 bytes, "C(auto)" */
1165 } else {
1166 int ret = parse_color(sb, placeholder, c);
1167 if (ret)
1168 c->auto_color = 0;
1169 /*
1170 * Otherwise, we decided to treat %C<unknown>
1171 * as a literal string, and the previous
1172 * %C(auto) is still valid.
1173 */
1174 return ret;
1175 }
1176 case 'w':
1177 if (placeholder[1] == '(') {
1178 unsigned long width = 0, indent1 = 0, indent2 = 0;
1179 char *next;
1180 const char *start = placeholder + 2;
1181 const char *end = strchr(start, ')');
1182 if (!end)
1183 return 0;
1184 if (end > start) {
1185 width = strtoul(start, &next, 10);
1186 if (*next == ',') {
1187 indent1 = strtoul(next + 1, &next, 10);
1188 if (*next == ',') {
1189 indent2 = strtoul(next + 1,
1190 &next, 10);
1191 }
1192 }
1193 if (*next != ')')
1194 return 0;
1195 }
1196 rewrap_message_tail(sb, c, width, indent1, indent2);
1197 return end - placeholder + 1;
1198 } else
1199 return 0;
1200
1201 case '<':
1202 case '>':
1203 return parse_padding_placeholder(placeholder, c);
1204 }
1205
1206 /* these depend on the commit */
1207 if (!commit->object.parsed)
1208 parse_object(the_repository, &commit->object.oid);
1209
1210 switch (placeholder[0]) {
1211 case 'H': /* commit hash */
1212 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_COMMIT));
1213 strbuf_addstr(sb, oid_to_hex(&commit->object.oid));
1214 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
1215 return 1;
1216 case 'h': /* abbreviated commit hash */
1217 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_COMMIT));
1218 strbuf_add_unique_abbrev(sb, &commit->object.oid,
1219 c->pretty_ctx->abbrev);
1220 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
1221 return 1;
1222 case 'T': /* tree hash */
1223 strbuf_addstr(sb, oid_to_hex(get_commit_tree_oid(commit)));
1224 return 1;
1225 case 't': /* abbreviated tree hash */
1226 strbuf_add_unique_abbrev(sb,
1227 get_commit_tree_oid(commit),
1228 c->pretty_ctx->abbrev);
1229 return 1;
1230 case 'P': /* parent hashes */
1231 for (p = commit->parents; p; p = p->next) {
1232 if (p != commit->parents)
1233 strbuf_addch(sb, ' ');
1234 strbuf_addstr(sb, oid_to_hex(&p->item->object.oid));
1235 }
1236 return 1;
1237 case 'p': /* abbreviated parent hashes */
1238 for (p = commit->parents; p; p = p->next) {
1239 if (p != commit->parents)
1240 strbuf_addch(sb, ' ');
1241 strbuf_add_unique_abbrev(sb, &p->item->object.oid,
1242 c->pretty_ctx->abbrev);
1243 }
1244 return 1;
1245 case 'm': /* left/right/bottom */
1246 strbuf_addstr(sb, get_revision_mark(NULL, commit));
1247 return 1;
1248 case 'd':
1249 format_decorations(sb, commit, c->auto_color);
1250 return 1;
1251 case 'D':
1252 format_decorations_extended(sb, commit, c->auto_color, "", ", ", "");
1253 return 1;
1254 case 'S': /* tag/branch like --source */
1255 if (!(c->pretty_ctx->rev && c->pretty_ctx->rev->sources))
1256 return 0;
1257 slot = revision_sources_at(c->pretty_ctx->rev->sources, commit);
1258 if (!(slot && *slot))
1259 return 0;
1260 strbuf_addstr(sb, *slot);
1261 return 1;
1262 case 'g': /* reflog info */
1263 switch(placeholder[1]) {
1264 case 'd': /* reflog selector */
1265 case 'D':
1266 if (c->pretty_ctx->reflog_info)
1267 get_reflog_selector(sb,
1268 c->pretty_ctx->reflog_info,
1269 &c->pretty_ctx->date_mode,
1270 c->pretty_ctx->date_mode_explicit,
1271 (placeholder[1] == 'd'));
1272 return 2;
1273 case 's': /* reflog message */
1274 if (c->pretty_ctx->reflog_info)
1275 get_reflog_message(sb, c->pretty_ctx->reflog_info);
1276 return 2;
1277 case 'n':
1278 case 'N':
1279 case 'e':
1280 case 'E':
1281 return format_reflog_person(sb,
1282 placeholder[1],
1283 c->pretty_ctx->reflog_info,
1284 &c->pretty_ctx->date_mode);
1285 }
1286 return 0; /* unknown %g placeholder */
1287 case 'N':
1288 if (c->pretty_ctx->notes_message) {
1289 strbuf_addstr(sb, c->pretty_ctx->notes_message);
1290 return 1;
1291 }
1292 return 0;
1293 }
1294
1295 if (placeholder[0] == 'G') {
1296 if (!c->signature_check.result)
1297 check_commit_signature(c->commit, &(c->signature_check));
1298 switch (placeholder[1]) {
1299 case 'G':
1300 if (c->signature_check.gpg_output)
1301 strbuf_addstr(sb, c->signature_check.gpg_output);
1302 break;
1303 case '?':
1304 switch (c->signature_check.result) {
1305 case 'G':
1306 case 'B':
1307 case 'E':
1308 case 'U':
1309 case 'N':
1310 case 'X':
1311 case 'Y':
1312 case 'R':
1313 strbuf_addch(sb, c->signature_check.result);
1314 }
1315 break;
1316 case 'S':
1317 if (c->signature_check.signer)
1318 strbuf_addstr(sb, c->signature_check.signer);
1319 break;
1320 case 'K':
1321 if (c->signature_check.key)
1322 strbuf_addstr(sb, c->signature_check.key);
1323 break;
1324 case 'F':
1325 if (c->signature_check.fingerprint)
1326 strbuf_addstr(sb, c->signature_check.fingerprint);
1327 break;
1328 case 'P':
1329 if (c->signature_check.primary_key_fingerprint)
1330 strbuf_addstr(sb, c->signature_check.primary_key_fingerprint);
1331 break;
1332 default:
1333 return 0;
1334 }
1335 return 2;
1336 }
1337
1338
1339 /* For the rest we have to parse the commit header. */
1340 if (!c->commit_header_parsed)
1341 parse_commit_header(c);
1342
1343 switch (placeholder[0]) {
1344 case 'a': /* author ... */
1345 return format_person_part(sb, placeholder[1],
1346 msg + c->author.off, c->author.len,
1347 &c->pretty_ctx->date_mode);
1348 case 'c': /* committer ... */
1349 return format_person_part(sb, placeholder[1],
1350 msg + c->committer.off, c->committer.len,
1351 &c->pretty_ctx->date_mode);
1352 case 'e': /* encoding */
1353 if (c->commit_encoding)
1354 strbuf_addstr(sb, c->commit_encoding);
1355 return 1;
1356 case 'B': /* raw body */
1357 /* message_off is always left at the initial newline */
1358 strbuf_addstr(sb, msg + c->message_off + 1);
1359 return 1;
1360 }
1361
1362 /* Now we need to parse the commit message. */
1363 if (!c->commit_message_parsed)
1364 parse_commit_message(c);
1365
1366 switch (placeholder[0]) {
1367 case 's': /* subject */
1368 format_subject(sb, msg + c->subject_off, " ");
1369 return 1;
1370 case 'f': /* sanitized subject */
1371 format_sanitized_subject(sb, msg + c->subject_off);
1372 return 1;
1373 case 'b': /* body */
1374 strbuf_addstr(sb, msg + c->body_off);
1375 return 1;
1376 }
1377
1378 if (skip_prefix(placeholder, "(trailers", &arg)) {
1379 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
1380 struct string_list filter_list = STRING_LIST_INIT_NODUP;
1381 struct strbuf sepbuf = STRBUF_INIT;
1382 size_t ret = 0;
1383
1384 opts.no_divider = 1;
1385
1386 if (*arg == ':') {
1387 arg++;
1388 for (;;) {
1389 const char *argval;
1390 size_t arglen;
1391
1392 if (match_placeholder_arg_value(arg, "key", &arg, &argval, &arglen)) {
1393 uintptr_t len = arglen;
1394
1395 if (!argval)
1396 goto trailer_out;
1397
1398 if (len && argval[len - 1] == ':')
1399 len--;
1400 string_list_append(&filter_list, argval)->util = (char *)len;
1401
1402 opts.filter = format_trailer_match_cb;
1403 opts.filter_data = &filter_list;
1404 opts.only_trailers = 1;
1405 } else if (match_placeholder_arg_value(arg, "separator", &arg, &argval, &arglen)) {
1406 char *fmt;
1407
1408 strbuf_reset(&sepbuf);
1409 fmt = xstrndup(argval, arglen);
1410 strbuf_expand(&sepbuf, fmt, strbuf_expand_literal_cb, NULL);
1411 free(fmt);
1412 opts.separator = &sepbuf;
1413 } else if (!match_placeholder_bool_arg(arg, "only", &arg, &opts.only_trailers) &&
1414 !match_placeholder_bool_arg(arg, "unfold", &arg, &opts.unfold) &&
1415 !match_placeholder_bool_arg(arg, "valueonly", &arg, &opts.value_only))
1416 break;
1417 }
1418 }
1419 if (*arg == ')') {
1420 format_trailers_from_commit(sb, msg + c->subject_off, &opts);
1421 ret = arg - placeholder + 1;
1422 }
1423 trailer_out:
1424 string_list_clear(&filter_list, 0);
1425 strbuf_release(&sepbuf);
1426 return ret;
1427 }
1428
1429 return 0; /* unknown placeholder */
1430 }
1431
1432 static size_t format_and_pad_commit(struct strbuf *sb, /* in UTF-8 */
1433 const char *placeholder,
1434 struct format_commit_context *c)
1435 {
1436 struct strbuf local_sb = STRBUF_INIT;
1437 int total_consumed = 0, len, padding = c->padding;
1438 if (padding < 0) {
1439 const char *start = strrchr(sb->buf, '\n');
1440 int occupied;
1441 if (!start)
1442 start = sb->buf;
1443 occupied = utf8_strnwidth(start, -1, 1);
1444 occupied += c->pretty_ctx->graph_width;
1445 padding = (-padding) - occupied;
1446 }
1447 while (1) {
1448 int modifier = *placeholder == 'C';
1449 int consumed = format_commit_one(&local_sb, placeholder, c);
1450 total_consumed += consumed;
1451
1452 if (!modifier)
1453 break;
1454
1455 placeholder += consumed;
1456 if (*placeholder != '%')
1457 break;
1458 placeholder++;
1459 total_consumed++;
1460 }
1461 len = utf8_strnwidth(local_sb.buf, -1, 1);
1462
1463 if (c->flush_type == flush_left_and_steal) {
1464 const char *ch = sb->buf + sb->len - 1;
1465 while (len > padding && ch > sb->buf) {
1466 const char *p;
1467 if (*ch == ' ') {
1468 ch--;
1469 padding++;
1470 continue;
1471 }
1472 /* check for trailing ansi sequences */
1473 if (*ch != 'm')
1474 break;
1475 p = ch - 1;
1476 while (ch - p < 10 && *p != '\033')
1477 p--;
1478 if (*p != '\033' ||
1479 ch + 1 - p != display_mode_esc_sequence_len(p))
1480 break;
1481 /*
1482 * got a good ansi sequence, put it back to
1483 * local_sb as we're cutting sb
1484 */
1485 strbuf_insert(&local_sb, 0, p, ch + 1 - p);
1486 ch = p - 1;
1487 }
1488 strbuf_setlen(sb, ch + 1 - sb->buf);
1489 c->flush_type = flush_left;
1490 }
1491
1492 if (len > padding) {
1493 switch (c->truncate) {
1494 case trunc_left:
1495 strbuf_utf8_replace(&local_sb,
1496 0, len - (padding - 2),
1497 "..");
1498 break;
1499 case trunc_middle:
1500 strbuf_utf8_replace(&local_sb,
1501 padding / 2 - 1,
1502 len - (padding - 2),
1503 "..");
1504 break;
1505 case trunc_right:
1506 strbuf_utf8_replace(&local_sb,
1507 padding - 2, len - (padding - 2),
1508 "..");
1509 break;
1510 case trunc_none:
1511 break;
1512 }
1513 strbuf_addbuf(sb, &local_sb);
1514 } else {
1515 int sb_len = sb->len, offset = 0;
1516 if (c->flush_type == flush_left)
1517 offset = padding - len;
1518 else if (c->flush_type == flush_both)
1519 offset = (padding - len) / 2;
1520 /*
1521 * we calculate padding in columns, now
1522 * convert it back to chars
1523 */
1524 padding = padding - len + local_sb.len;
1525 strbuf_addchars(sb, ' ', padding);
1526 memcpy(sb->buf + sb_len + offset, local_sb.buf,
1527 local_sb.len);
1528 }
1529 strbuf_release(&local_sb);
1530 c->flush_type = no_flush;
1531 return total_consumed;
1532 }
1533
1534 static size_t format_commit_item(struct strbuf *sb, /* in UTF-8 */
1535 const char *placeholder,
1536 void *context)
1537 {
1538 int consumed;
1539 size_t orig_len;
1540 enum {
1541 NO_MAGIC,
1542 ADD_LF_BEFORE_NON_EMPTY,
1543 DEL_LF_BEFORE_EMPTY,
1544 ADD_SP_BEFORE_NON_EMPTY
1545 } magic = NO_MAGIC;
1546
1547 switch (placeholder[0]) {
1548 case '-':
1549 magic = DEL_LF_BEFORE_EMPTY;
1550 break;
1551 case '+':
1552 magic = ADD_LF_BEFORE_NON_EMPTY;
1553 break;
1554 case ' ':
1555 magic = ADD_SP_BEFORE_NON_EMPTY;
1556 break;
1557 default:
1558 break;
1559 }
1560 if (magic != NO_MAGIC)
1561 placeholder++;
1562
1563 orig_len = sb->len;
1564 if (((struct format_commit_context *)context)->flush_type != no_flush)
1565 consumed = format_and_pad_commit(sb, placeholder, context);
1566 else
1567 consumed = format_commit_one(sb, placeholder, context);
1568 if (magic == NO_MAGIC)
1569 return consumed;
1570
1571 if ((orig_len == sb->len) && magic == DEL_LF_BEFORE_EMPTY) {
1572 while (sb->len && sb->buf[sb->len - 1] == '\n')
1573 strbuf_setlen(sb, sb->len - 1);
1574 } else if (orig_len != sb->len) {
1575 if (magic == ADD_LF_BEFORE_NON_EMPTY)
1576 strbuf_insert(sb, orig_len, "\n", 1);
1577 else if (magic == ADD_SP_BEFORE_NON_EMPTY)
1578 strbuf_insert(sb, orig_len, " ", 1);
1579 }
1580 return consumed + 1;
1581 }
1582
1583 static size_t userformat_want_item(struct strbuf *sb, const char *placeholder,
1584 void *context)
1585 {
1586 struct userformat_want *w = context;
1587
1588 if (*placeholder == '+' || *placeholder == '-' || *placeholder == ' ')
1589 placeholder++;
1590
1591 switch (*placeholder) {
1592 case 'N':
1593 w->notes = 1;
1594 break;
1595 case 'S':
1596 w->source = 1;
1597 break;
1598 }
1599 return 0;
1600 }
1601
1602 void userformat_find_requirements(const char *fmt, struct userformat_want *w)
1603 {
1604 struct strbuf dummy = STRBUF_INIT;
1605
1606 if (!fmt) {
1607 if (!user_format)
1608 return;
1609 fmt = user_format;
1610 }
1611 strbuf_expand(&dummy, fmt, userformat_want_item, w);
1612 strbuf_release(&dummy);
1613 }
1614
1615 void repo_format_commit_message(struct repository *r,
1616 const struct commit *commit,
1617 const char *format, struct strbuf *sb,
1618 const struct pretty_print_context *pretty_ctx)
1619 {
1620 struct format_commit_context context;
1621 const char *output_enc = pretty_ctx->output_encoding;
1622 const char *utf8 = "UTF-8";
1623
1624 memset(&context, 0, sizeof(context));
1625 context.commit = commit;
1626 context.pretty_ctx = pretty_ctx;
1627 context.wrap_start = sb->len;
1628 /*
1629 * convert a commit message to UTF-8 first
1630 * as far as 'format_commit_item' assumes it in UTF-8
1631 */
1632 context.message = repo_logmsg_reencode(r, commit,
1633 &context.commit_encoding,
1634 utf8);
1635
1636 strbuf_expand(sb, format, format_commit_item, &context);
1637 rewrap_message_tail(sb, &context, 0, 0, 0);
1638
1639 /* then convert a commit message to an actual output encoding */
1640 if (output_enc) {
1641 if (same_encoding(utf8, output_enc))
1642 output_enc = NULL;
1643 } else {
1644 if (context.commit_encoding &&
1645 !same_encoding(context.commit_encoding, utf8))
1646 output_enc = context.commit_encoding;
1647 }
1648
1649 if (output_enc) {
1650 size_t outsz;
1651 char *out = reencode_string_len(sb->buf, sb->len,
1652 output_enc, utf8, &outsz);
1653 if (out)
1654 strbuf_attach(sb, out, outsz, outsz + 1);
1655 }
1656
1657 free(context.commit_encoding);
1658 repo_unuse_commit_buffer(r, commit, context.message);
1659 }
1660
1661 static void pp_header(struct pretty_print_context *pp,
1662 const char *encoding,
1663 const struct commit *commit,
1664 const char **msg_p,
1665 struct strbuf *sb)
1666 {
1667 int parents_shown = 0;
1668
1669 for (;;) {
1670 const char *name, *line = *msg_p;
1671 int linelen = get_one_line(*msg_p);
1672
1673 if (!linelen)
1674 return;
1675 *msg_p += linelen;
1676
1677 if (linelen == 1)
1678 /* End of header */
1679 return;
1680
1681 if (pp->fmt == CMIT_FMT_RAW) {
1682 strbuf_add(sb, line, linelen);
1683 continue;
1684 }
1685
1686 if (starts_with(line, "parent ")) {
1687 if (linelen != the_hash_algo->hexsz + 8)
1688 die("bad parent line in commit");
1689 continue;
1690 }
1691
1692 if (!parents_shown) {
1693 unsigned num = commit_list_count(commit->parents);
1694 /* with enough slop */
1695 strbuf_grow(sb, num * (GIT_MAX_HEXSZ + 10) + 20);
1696 add_merge_info(pp, sb, commit);
1697 parents_shown = 1;
1698 }
1699
1700 /*
1701 * MEDIUM == DEFAULT shows only author with dates.
1702 * FULL shows both authors but not dates.
1703 * FULLER shows both authors and dates.
1704 */
1705 if (skip_prefix(line, "author ", &name)) {
1706 strbuf_grow(sb, linelen + 80);
1707 pp_user_info(pp, "Author", sb, name, encoding);
1708 }
1709 if (skip_prefix(line, "committer ", &name) &&
1710 (pp->fmt == CMIT_FMT_FULL || pp->fmt == CMIT_FMT_FULLER)) {
1711 strbuf_grow(sb, linelen + 80);
1712 pp_user_info(pp, "Commit", sb, name, encoding);
1713 }
1714 }
1715 }
1716
1717 void pp_title_line(struct pretty_print_context *pp,
1718 const char **msg_p,
1719 struct strbuf *sb,
1720 const char *encoding,
1721 int need_8bit_cte)
1722 {
1723 static const int max_length = 78; /* per rfc2047 */
1724 struct strbuf title;
1725
1726 strbuf_init(&title, 80);
1727 *msg_p = format_subject(&title, *msg_p,
1728 pp->preserve_subject ? "\n" : " ");
1729
1730 strbuf_grow(sb, title.len + 1024);
1731 if (pp->print_email_subject) {
1732 if (pp->rev)
1733 fmt_output_email_subject(sb, pp->rev);
1734 if (needs_rfc2047_encoding(title.buf, title.len))
1735 add_rfc2047(sb, title.buf, title.len,
1736 encoding, RFC2047_SUBJECT);
1737 else
1738 strbuf_add_wrapped_bytes(sb, title.buf, title.len,
1739 -last_line_length(sb), 1, max_length);
1740 } else {
1741 strbuf_addbuf(sb, &title);
1742 }
1743 strbuf_addch(sb, '\n');
1744
1745 if (need_8bit_cte == 0) {
1746 int i;
1747 for (i = 0; i < pp->in_body_headers.nr; i++) {
1748 if (has_non_ascii(pp->in_body_headers.items[i].string)) {
1749 need_8bit_cte = 1;
1750 break;
1751 }
1752 }
1753 }
1754
1755 if (need_8bit_cte > 0) {
1756 const char *header_fmt =
1757 "MIME-Version: 1.0\n"
1758 "Content-Type: text/plain; charset=%s\n"
1759 "Content-Transfer-Encoding: 8bit\n";
1760 strbuf_addf(sb, header_fmt, encoding);
1761 }
1762 if (pp->after_subject) {
1763 strbuf_addstr(sb, pp->after_subject);
1764 }
1765 if (cmit_fmt_is_mail(pp->fmt)) {
1766 strbuf_addch(sb, '\n');
1767 }
1768
1769 if (pp->in_body_headers.nr) {
1770 int i;
1771 for (i = 0; i < pp->in_body_headers.nr; i++) {
1772 strbuf_addstr(sb, pp->in_body_headers.items[i].string);
1773 free(pp->in_body_headers.items[i].string);
1774 }
1775 string_list_clear(&pp->in_body_headers, 0);
1776 strbuf_addch(sb, '\n');
1777 }
1778
1779 strbuf_release(&title);
1780 }
1781
1782 static int pp_utf8_width(const char *start, const char *end)
1783 {
1784 int width = 0;
1785 size_t remain = end - start;
1786
1787 while (remain) {
1788 int n = utf8_width(&start, &remain);
1789 if (n < 0 || !start)
1790 return -1;
1791 width += n;
1792 }
1793 return width;
1794 }
1795
1796 static void strbuf_add_tabexpand(struct strbuf *sb, int tabwidth,
1797 const char *line, int linelen)
1798 {
1799 const char *tab;
1800
1801 while ((tab = memchr(line, '\t', linelen)) != NULL) {
1802 int width = pp_utf8_width(line, tab);
1803
1804 /*
1805 * If it wasn't well-formed utf8, or it
1806 * had characters with badly defined
1807 * width (control characters etc), just
1808 * give up on trying to align things.
1809 */
1810 if (width < 0)
1811 break;
1812
1813 /* Output the data .. */
1814 strbuf_add(sb, line, tab - line);
1815
1816 /* .. and the de-tabified tab */
1817 strbuf_addchars(sb, ' ', tabwidth - (width % tabwidth));
1818
1819 /* Skip over the printed part .. */
1820 linelen -= tab + 1 - line;
1821 line = tab + 1;
1822 }
1823
1824 /*
1825 * Print out everything after the last tab without
1826 * worrying about width - there's nothing more to
1827 * align.
1828 */
1829 strbuf_add(sb, line, linelen);
1830 }
1831
1832 /*
1833 * pp_handle_indent() prints out the intendation, and
1834 * the whole line (without the final newline), after
1835 * de-tabifying.
1836 */
1837 static void pp_handle_indent(struct pretty_print_context *pp,
1838 struct strbuf *sb, int indent,
1839 const char *line, int linelen)
1840 {
1841 strbuf_addchars(sb, ' ', indent);
1842 if (pp->expand_tabs_in_log)
1843 strbuf_add_tabexpand(sb, pp->expand_tabs_in_log, line, linelen);
1844 else
1845 strbuf_add(sb, line, linelen);
1846 }
1847
1848 static int is_mboxrd_from(const char *line, int len)
1849 {
1850 /*
1851 * a line matching /^From $/ here would only have len == 4
1852 * at this point because is_empty_line would've trimmed all
1853 * trailing space
1854 */
1855 return len > 4 && starts_with(line + strspn(line, ">"), "From ");
1856 }
1857
1858 void pp_remainder(struct pretty_print_context *pp,
1859 const char **msg_p,
1860 struct strbuf *sb,
1861 int indent)
1862 {
1863 int first = 1;
1864 for (;;) {
1865 const char *line = *msg_p;
1866 int linelen = get_one_line(line);
1867 *msg_p += linelen;
1868
1869 if (!linelen)
1870 break;
1871
1872 if (is_blank_line(line, &linelen)) {
1873 if (first)
1874 continue;
1875 if (pp->fmt == CMIT_FMT_SHORT)
1876 break;
1877 }
1878 first = 0;
1879
1880 strbuf_grow(sb, linelen + indent + 20);
1881 if (indent)
1882 pp_handle_indent(pp, sb, indent, line, linelen);
1883 else if (pp->expand_tabs_in_log)
1884 strbuf_add_tabexpand(sb, pp->expand_tabs_in_log,
1885 line, linelen);
1886 else {
1887 if (pp->fmt == CMIT_FMT_MBOXRD &&
1888 is_mboxrd_from(line, linelen))
1889 strbuf_addch(sb, '>');
1890
1891 strbuf_add(sb, line, linelen);
1892 }
1893 strbuf_addch(sb, '\n');
1894 }
1895 }
1896
1897 void pretty_print_commit(struct pretty_print_context *pp,
1898 const struct commit *commit,
1899 struct strbuf *sb)
1900 {
1901 unsigned long beginning_of_body;
1902 int indent = 4;
1903 const char *msg;
1904 const char *reencoded;
1905 const char *encoding;
1906 int need_8bit_cte = pp->need_8bit_cte;
1907
1908 if (pp->fmt == CMIT_FMT_USERFORMAT) {
1909 format_commit_message(commit, user_format, sb, pp);
1910 return;
1911 }
1912
1913 encoding = get_log_output_encoding();
1914 msg = reencoded = logmsg_reencode(commit, NULL, encoding);
1915
1916 if (pp->fmt == CMIT_FMT_ONELINE || cmit_fmt_is_mail(pp->fmt))
1917 indent = 0;
1918
1919 /*
1920 * We need to check and emit Content-type: to mark it
1921 * as 8-bit if we haven't done so.
1922 */
1923 if (cmit_fmt_is_mail(pp->fmt) && need_8bit_cte == 0) {
1924 int i, ch, in_body;
1925
1926 for (in_body = i = 0; (ch = msg[i]); i++) {
1927 if (!in_body) {
1928 /* author could be non 7-bit ASCII but
1929 * the log may be so; skip over the
1930 * header part first.
1931 */
1932 if (ch == '\n' && msg[i+1] == '\n')
1933 in_body = 1;
1934 }
1935 else if (non_ascii(ch)) {
1936 need_8bit_cte = 1;
1937 break;
1938 }
1939 }
1940 }
1941
1942 pp_header(pp, encoding, commit, &msg, sb);
1943 if (pp->fmt != CMIT_FMT_ONELINE && !pp->print_email_subject) {
1944 strbuf_addch(sb, '\n');
1945 }
1946
1947 /* Skip excess blank lines at the beginning of body, if any... */
1948 msg = skip_blank_lines(msg);
1949
1950 /* These formats treat the title line specially. */
1951 if (pp->fmt == CMIT_FMT_ONELINE || cmit_fmt_is_mail(pp->fmt))
1952 pp_title_line(pp, &msg, sb, encoding, need_8bit_cte);
1953
1954 beginning_of_body = sb->len;
1955 if (pp->fmt != CMIT_FMT_ONELINE)
1956 pp_remainder(pp, &msg, sb, indent);
1957 strbuf_rtrim(sb);
1958
1959 /* Make sure there is an EOLN for the non-oneline case */
1960 if (pp->fmt != CMIT_FMT_ONELINE)
1961 strbuf_addch(sb, '\n');
1962
1963 /*
1964 * The caller may append additional body text in e-mail
1965 * format. Make sure we did not strip the blank line
1966 * between the header and the body.
1967 */
1968 if (cmit_fmt_is_mail(pp->fmt) && sb->len <= beginning_of_body)
1969 strbuf_addch(sb, '\n');
1970
1971 unuse_commit_buffer(commit, reencoded);
1972 }
1973
1974 void pp_commit_easy(enum cmit_fmt fmt, const struct commit *commit,
1975 struct strbuf *sb)
1976 {
1977 struct pretty_print_context pp = {0};
1978 pp.fmt = fmt;
1979 pretty_print_commit(&pp, commit, sb);
1980 }
The Best VCS Around