?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'ew/server-info-remove-crufts'
[git.git] / pretty.c
blobced0485257d3190f0c3ad8b89f15fa47c8660fad
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 memcpy(commit_formats, builtin_formats,
110 sizeof(*builtin_formats)*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') /* 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
710 if (!s.date_begin)
711 goto skip;
712
713 if (part == 't') { /* date, UNIX timestamp */
714 strbuf_add(sb, s.date_begin, s.date_end - s.date_begin);
715 return placeholder_len;
716 }
717
718 switch (part) {
719 case 'd': /* date */
720 strbuf_addstr(sb, show_ident_date(&s, dmode));
721 return placeholder_len;
722 case 'D': /* date, RFC2822 style */
723 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(RFC2822)));
724 return placeholder_len;
725 case 'r': /* date, relative */
726 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(RELATIVE)));
727 return placeholder_len;
728 case 'i': /* date, ISO 8601-like */
729 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(ISO8601)));
730 return placeholder_len;
731 case 'I': /* date, ISO 8601 strict */
732 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(ISO8601_STRICT)));
733 return placeholder_len;
734 }
735
736 skip:
737 /*
738 * reading from either a bogus commit, or a reflog entry with
739 * %gn, %ge, etc.; 'sb' cannot be updated, but we still need
740 * to compute a valid return value.
741 */
742 if (part == 'n' || part == 'e' || part == 't' || part == 'd'
743 || part == 'D' || part == 'r' || part == 'i')
744 return placeholder_len;
745
746 return 0; /* unknown placeholder */
747 }
748
749 struct chunk {
750 size_t off;
751 size_t len;
752 };
753
754 enum flush_type {
755 no_flush,
756 flush_right,
757 flush_left,
758 flush_left_and_steal,
759 flush_both
760 };
761
762 enum trunc_type {
763 trunc_none,
764 trunc_left,
765 trunc_middle,
766 trunc_right
767 };
768
769 struct format_commit_context {
770 const struct commit *commit;
771 const struct pretty_print_context *pretty_ctx;
772 unsigned commit_header_parsed:1;
773 unsigned commit_message_parsed:1;
774 struct signature_check signature_check;
775 enum flush_type flush_type;
776 enum trunc_type truncate;
777 const char *message;
778 char *commit_encoding;
779 size_t width, indent1, indent2;
780 int auto_color;
781 int padding;
782
783 /* These offsets are relative to the start of the commit message. */
784 struct chunk author;
785 struct chunk committer;
786 size_t message_off;
787 size_t subject_off;
788 size_t body_off;
789
790 /* The following ones are relative to the result struct strbuf. */
791 size_t wrap_start;
792 };
793
794 static void parse_commit_header(struct format_commit_context *context)
795 {
796 const char *msg = context->message;
797 int i;
798
799 for (i = 0; msg[i]; i++) {
800 const char *name;
801 int eol;
802 for (eol = i; msg[eol] && msg[eol] != '\n'; eol++)
803 ; /* do nothing */
804
805 if (i == eol) {
806 break;
807 } else if (skip_prefix(msg + i, "author ", &name)) {
808 context->author.off = name - msg;
809 context->author.len = msg + eol - name;
810 } else if (skip_prefix(msg + i, "committer ", &name)) {
811 context->committer.off = name - msg;
812 context->committer.len = msg + eol - name;
813 }
814 i = eol;
815 }
816 context->message_off = i;
817 context->commit_header_parsed = 1;
818 }
819
820 static int istitlechar(char c)
821 {
822 return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
823 (c >= '0' && c <= '9') || c == '.' || c == '_';
824 }
825
826 static void format_sanitized_subject(struct strbuf *sb, const char *msg)
827 {
828 size_t trimlen;
829 size_t start_len = sb->len;
830 int space = 2;
831
832 for (; *msg && *msg != '\n'; msg++) {
833 if (istitlechar(*msg)) {
834 if (space == 1)
835 strbuf_addch(sb, '-');
836 space = 0;
837 strbuf_addch(sb, *msg);
838 if (*msg == '.')
839 while (*(msg+1) == '.')
840 msg++;
841 } else
842 space |= 1;
843 }
844
845 /* trim any trailing '.' or '-' characters */
846 trimlen = 0;
847 while (sb->len - trimlen > start_len &&
848 (sb->buf[sb->len - 1 - trimlen] == '.'
849 || sb->buf[sb->len - 1 - trimlen] == '-'))
850 trimlen++;
851 strbuf_remove(sb, sb->len - trimlen, trimlen);
852 }
853
854 const char *format_subject(struct strbuf *sb, const char *msg,
855 const char *line_separator)
856 {
857 int first = 1;
858
859 for (;;) {
860 const char *line = msg;
861 int linelen = get_one_line(line);
862
863 msg += linelen;
864 if (!linelen || is_blank_line(line, &linelen))
865 break;
866
867 if (!sb)
868 continue;
869 strbuf_grow(sb, linelen + 2);
870 if (!first)
871 strbuf_addstr(sb, line_separator);
872 strbuf_add(sb, line, linelen);
873 first = 0;
874 }
875 return msg;
876 }
877
878 static void parse_commit_message(struct format_commit_context *c)
879 {
880 const char *msg = c->message + c->message_off;
881 const char *start = c->message;
882
883 msg = skip_blank_lines(msg);
884 c->subject_off = msg - start;
885
886 msg = format_subject(NULL, msg, NULL);
887 msg = skip_blank_lines(msg);
888 c->body_off = msg - start;
889
890 c->commit_message_parsed = 1;
891 }
892
893 static void strbuf_wrap(struct strbuf *sb, size_t pos,
894 size_t width, size_t indent1, size_t indent2)
895 {
896 struct strbuf tmp = STRBUF_INIT;
897
898 if (pos)
899 strbuf_add(&tmp, sb->buf, pos);
900 strbuf_add_wrapped_text(&tmp, sb->buf + pos,
901 (int) indent1, (int) indent2, (int) width);
902 strbuf_swap(&tmp, sb);
903 strbuf_release(&tmp);
904 }
905
906 static void rewrap_message_tail(struct strbuf *sb,
907 struct format_commit_context *c,
908 size_t new_width, size_t new_indent1,
909 size_t new_indent2)
910 {
911 if (c->width == new_width && c->indent1 == new_indent1 &&
912 c->indent2 == new_indent2)
913 return;
914 if (c->wrap_start < sb->len)
915 strbuf_wrap(sb, c->wrap_start, c->width, c->indent1, c->indent2);
916 c->wrap_start = sb->len;
917 c->width = new_width;
918 c->indent1 = new_indent1;
919 c->indent2 = new_indent2;
920 }
921
922 static int format_reflog_person(struct strbuf *sb,
923 char part,
924 struct reflog_walk_info *log,
925 const struct date_mode *dmode)
926 {
927 const char *ident;
928
929 if (!log)
930 return 2;
931
932 ident = get_reflog_ident(log);
933 if (!ident)
934 return 2;
935
936 return format_person_part(sb, part, ident, strlen(ident), dmode);
937 }
938
939 static size_t parse_color(struct strbuf *sb, /* in UTF-8 */
940 const char *placeholder,
941 struct format_commit_context *c)
942 {
943 const char *rest = placeholder;
944 const char *basic_color = NULL;
945
946 if (placeholder[1] == '(') {
947 const char *begin = placeholder + 2;
948 const char *end = strchr(begin, ')');
949 char color[COLOR_MAXLEN];
950
951 if (!end)
952 return 0;
953
954 if (skip_prefix(begin, "auto,", &begin)) {
955 if (!want_color(c->pretty_ctx->color))
956 return end - placeholder + 1;
957 } else if (skip_prefix(begin, "always,", &begin)) {
958 /* nothing to do; we do not respect want_color at all */
959 } else {
960 /* the default is the same as "auto" */
961 if (!want_color(c->pretty_ctx->color))
962 return end - placeholder + 1;
963 }
964
965 if (color_parse_mem(begin, end - begin, color) < 0)
966 die(_("unable to parse --pretty format"));
967 strbuf_addstr(sb, color);
968 return end - placeholder + 1;
969 }
970
971 /*
972 * We handle things like "%C(red)" above; for historical reasons, there
973 * are a few colors that can be specified without parentheses (and
974 * they cannot support things like "auto" or "always" at all).
975 */
976 if (skip_prefix(placeholder + 1, "red", &rest))
977 basic_color = GIT_COLOR_RED;
978 else if (skip_prefix(placeholder + 1, "green", &rest))
979 basic_color = GIT_COLOR_GREEN;
980 else if (skip_prefix(placeholder + 1, "blue", &rest))
981 basic_color = GIT_COLOR_BLUE;
982 else if (skip_prefix(placeholder + 1, "reset", &rest))
983 basic_color = GIT_COLOR_RESET;
984
985 if (basic_color && want_color(c->pretty_ctx->color))
986 strbuf_addstr(sb, basic_color);
987
988 return rest - placeholder;
989 }
990
991 static size_t parse_padding_placeholder(const char *placeholder,
992 struct format_commit_context *c)
993 {
994 const char *ch = placeholder;
995 enum flush_type flush_type;
996 int to_column = 0;
997
998 switch (*ch++) {
999 case '<':
1000 flush_type = flush_right;
1001 break;
1002 case '>':
1003 if (*ch == '<') {
1004 flush_type = flush_both;
1005 ch++;
1006 } else if (*ch == '>') {
1007 flush_type = flush_left_and_steal;
1008 ch++;
1009 } else
1010 flush_type = flush_left;
1011 break;
1012 default:
1013 return 0;
1014 }
1015
1016 /* the next value means "wide enough to that column" */
1017 if (*ch == '|') {
1018 to_column = 1;
1019 ch++;
1020 }
1021
1022 if (*ch == '(') {
1023 const char *start = ch + 1;
1024 const char *end = start + strcspn(start, ",)");
1025 char *next;
1026 int width;
1027 if (!end || end == start)
1028 return 0;
1029 width = strtol(start, &next, 10);
1030 if (next == start || width == 0)
1031 return 0;
1032 if (width < 0) {
1033 if (to_column)
1034 width += term_columns();
1035 if (width < 0)
1036 return 0;
1037 }
1038 c->padding = to_column ? -width : width;
1039 c->flush_type = flush_type;
1040
1041 if (*end == ',') {
1042 start = end + 1;
1043 end = strchr(start, ')');
1044 if (!end || end == start)
1045 return 0;
1046 if (starts_with(start, "trunc)"))
1047 c->truncate = trunc_right;
1048 else if (starts_with(start, "ltrunc)"))
1049 c->truncate = trunc_left;
1050 else if (starts_with(start, "mtrunc)"))
1051 c->truncate = trunc_middle;
1052 else
1053 return 0;
1054 } else
1055 c->truncate = trunc_none;
1056
1057 return end - placeholder + 1;
1058 }
1059 return 0;
1060 }
1061
1062 static int match_placeholder_arg_value(const char *to_parse, const char *candidate,
1063 const char **end, const char **valuestart,
1064 size_t *valuelen)
1065 {
1066 const char *p;
1067
1068 if (!(skip_prefix(to_parse, candidate, &p)))
1069 return 0;
1070 if (valuestart) {
1071 if (*p == '=') {
1072 *valuestart = p + 1;
1073 *valuelen = strcspn(*valuestart, ",)");
1074 p = *valuestart + *valuelen;
1075 } else {
1076 if (*p != ',' && *p != ')')
1077 return 0;
1078 *valuestart = NULL;
1079 *valuelen = 0;
1080 }
1081 }
1082 if (*p == ',') {
1083 *end = p + 1;
1084 return 1;
1085 }
1086 if (*p == ')') {
1087 *end = p;
1088 return 1;
1089 }
1090 return 0;
1091 }
1092
1093 static int match_placeholder_bool_arg(const char *to_parse, const char *candidate,
1094 const char **end, int *val)
1095 {
1096 const char *argval;
1097 char *strval;
1098 size_t arglen;
1099 int v;
1100
1101 if (!match_placeholder_arg_value(to_parse, candidate, end, &argval, &arglen))
1102 return 0;
1103
1104 if (!argval) {
1105 *val = 1;
1106 return 1;
1107 }
1108
1109 strval = xstrndup(argval, arglen);
1110 v = git_parse_maybe_bool(strval);
1111 free(strval);
1112
1113 if (v == -1)
1114 return 0;
1115
1116 *val = v;
1117
1118 return 1;
1119 }
1120
1121 static int format_trailer_match_cb(const struct strbuf *key, void *ud)
1122 {
1123 const struct string_list *list = ud;
1124 const struct string_list_item *item;
1125
1126 for_each_string_list_item (item, list) {
1127 if (key->len == (uintptr_t)item->util &&
1128 !strncasecmp(item->string, key->buf, key->len))
1129 return 1;
1130 }
1131 return 0;
1132 }
1133
1134 static size_t format_commit_one(struct strbuf *sb, /* in UTF-8 */
1135 const char *placeholder,
1136 void *context)
1137 {
1138 struct format_commit_context *c = context;
1139 const struct commit *commit = c->commit;
1140 const char *msg = c->message;
1141 struct commit_list *p;
1142 const char *arg;
1143 size_t res;
1144 char **slot;
1145
1146 /* these are independent of the commit */
1147 res = strbuf_expand_literal_cb(sb, placeholder, NULL);
1148 if (res)
1149 return res;
1150
1151 switch (placeholder[0]) {
1152 case 'C':
1153 if (starts_with(placeholder + 1, "(auto)")) {
1154 c->auto_color = want_color(c->pretty_ctx->color);
1155 if (c->auto_color && sb->len)
1156 strbuf_addstr(sb, GIT_COLOR_RESET);
1157 return 7; /* consumed 7 bytes, "C(auto)" */
1158 } else {
1159 int ret = parse_color(sb, placeholder, c);
1160 if (ret)
1161 c->auto_color = 0;
1162 /*
1163 * Otherwise, we decided to treat %C<unknown>
1164 * as a literal string, and the previous
1165 * %C(auto) is still valid.
1166 */
1167 return ret;
1168 }
1169 case 'w':
1170 if (placeholder[1] == '(') {
1171 unsigned long width = 0, indent1 = 0, indent2 = 0;
1172 char *next;
1173 const char *start = placeholder + 2;
1174 const char *end = strchr(start, ')');
1175 if (!end)
1176 return 0;
1177 if (end > start) {
1178 width = strtoul(start, &next, 10);
1179 if (*next == ',') {
1180 indent1 = strtoul(next + 1, &next, 10);
1181 if (*next == ',') {
1182 indent2 = strtoul(next + 1,
1183 &next, 10);
1184 }
1185 }
1186 if (*next != ')')
1187 return 0;
1188 }
1189 rewrap_message_tail(sb, c, width, indent1, indent2);
1190 return end - placeholder + 1;
1191 } else
1192 return 0;
1193
1194 case '<':
1195 case '>':
1196 return parse_padding_placeholder(placeholder, c);
1197 }
1198
1199 /* these depend on the commit */
1200 if (!commit->object.parsed)
1201 parse_object(the_repository, &commit->object.oid);
1202
1203 switch (placeholder[0]) {
1204 case 'H': /* commit hash */
1205 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_COMMIT));
1206 strbuf_addstr(sb, oid_to_hex(&commit->object.oid));
1207 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
1208 return 1;
1209 case 'h': /* abbreviated commit hash */
1210 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_COMMIT));
1211 strbuf_add_unique_abbrev(sb, &commit->object.oid,
1212 c->pretty_ctx->abbrev);
1213 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
1214 return 1;
1215 case 'T': /* tree hash */
1216 strbuf_addstr(sb, oid_to_hex(get_commit_tree_oid(commit)));
1217 return 1;
1218 case 't': /* abbreviated tree hash */
1219 strbuf_add_unique_abbrev(sb,
1220 get_commit_tree_oid(commit),
1221 c->pretty_ctx->abbrev);
1222 return 1;
1223 case 'P': /* parent hashes */
1224 for (p = commit->parents; p; p = p->next) {
1225 if (p != commit->parents)
1226 strbuf_addch(sb, ' ');
1227 strbuf_addstr(sb, oid_to_hex(&p->item->object.oid));
1228 }
1229 return 1;
1230 case 'p': /* abbreviated parent hashes */
1231 for (p = commit->parents; p; p = p->next) {
1232 if (p != commit->parents)
1233 strbuf_addch(sb, ' ');
1234 strbuf_add_unique_abbrev(sb, &p->item->object.oid,
1235 c->pretty_ctx->abbrev);
1236 }
1237 return 1;
1238 case 'm': /* left/right/bottom */
1239 strbuf_addstr(sb, get_revision_mark(NULL, commit));
1240 return 1;
1241 case 'd':
1242 load_ref_decorations(NULL, DECORATE_SHORT_REFS);
1243 format_decorations(sb, commit, c->auto_color);
1244 return 1;
1245 case 'D':
1246 load_ref_decorations(NULL, DECORATE_SHORT_REFS);
1247 format_decorations_extended(sb, commit, c->auto_color, "", ", ", "");
1248 return 1;
1249 case 'S': /* tag/branch like --source */
1250 if (!(c->pretty_ctx->rev && c->pretty_ctx->rev->sources))
1251 return 0;
1252 slot = revision_sources_at(c->pretty_ctx->rev->sources, commit);
1253 if (!(slot && *slot))
1254 return 0;
1255 strbuf_addstr(sb, *slot);
1256 return 1;
1257 case 'g': /* reflog info */
1258 switch(placeholder[1]) {
1259 case 'd': /* reflog selector */
1260 case 'D':
1261 if (c->pretty_ctx->reflog_info)
1262 get_reflog_selector(sb,
1263 c->pretty_ctx->reflog_info,
1264 &c->pretty_ctx->date_mode,
1265 c->pretty_ctx->date_mode_explicit,
1266 (placeholder[1] == 'd'));
1267 return 2;
1268 case 's': /* reflog message */
1269 if (c->pretty_ctx->reflog_info)
1270 get_reflog_message(sb, c->pretty_ctx->reflog_info);
1271 return 2;
1272 case 'n':
1273 case 'N':
1274 case 'e':
1275 case 'E':
1276 return format_reflog_person(sb,
1277 placeholder[1],
1278 c->pretty_ctx->reflog_info,
1279 &c->pretty_ctx->date_mode);
1280 }
1281 return 0; /* unknown %g placeholder */
1282 case 'N':
1283 if (c->pretty_ctx->notes_message) {
1284 strbuf_addstr(sb, c->pretty_ctx->notes_message);
1285 return 1;
1286 }
1287 return 0;
1288 }
1289
1290 if (placeholder[0] == 'G') {
1291 if (!c->signature_check.result)
1292 check_commit_signature(c->commit, &(c->signature_check));
1293 switch (placeholder[1]) {
1294 case 'G':
1295 if (c->signature_check.gpg_output)
1296 strbuf_addstr(sb, c->signature_check.gpg_output);
1297 break;
1298 case '?':
1299 switch (c->signature_check.result) {
1300 case 'G':
1301 case 'B':
1302 case 'E':
1303 case 'U':
1304 case 'N':
1305 case 'X':
1306 case 'Y':
1307 case 'R':
1308 strbuf_addch(sb, c->signature_check.result);
1309 }
1310 break;
1311 case 'S':
1312 if (c->signature_check.signer)
1313 strbuf_addstr(sb, c->signature_check.signer);
1314 break;
1315 case 'K':
1316 if (c->signature_check.key)
1317 strbuf_addstr(sb, c->signature_check.key);
1318 break;
1319 case 'F':
1320 if (c->signature_check.fingerprint)
1321 strbuf_addstr(sb, c->signature_check.fingerprint);
1322 break;
1323 case 'P':
1324 if (c->signature_check.primary_key_fingerprint)
1325 strbuf_addstr(sb, c->signature_check.primary_key_fingerprint);
1326 break;
1327 default:
1328 return 0;
1329 }
1330 return 2;
1331 }
1332
1333
1334 /* For the rest we have to parse the commit header. */
1335 if (!c->commit_header_parsed)
1336 parse_commit_header(c);
1337
1338 switch (placeholder[0]) {
1339 case 'a': /* author ... */
1340 return format_person_part(sb, placeholder[1],
1341 msg + c->author.off, c->author.len,
1342 &c->pretty_ctx->date_mode);
1343 case 'c': /* committer ... */
1344 return format_person_part(sb, placeholder[1],
1345 msg + c->committer.off, c->committer.len,
1346 &c->pretty_ctx->date_mode);
1347 case 'e': /* encoding */
1348 if (c->commit_encoding)
1349 strbuf_addstr(sb, c->commit_encoding);
1350 return 1;
1351 case 'B': /* raw body */
1352 /* message_off is always left at the initial newline */
1353 strbuf_addstr(sb, msg + c->message_off + 1);
1354 return 1;
1355 }
1356
1357 /* Now we need to parse the commit message. */
1358 if (!c->commit_message_parsed)
1359 parse_commit_message(c);
1360
1361 switch (placeholder[0]) {
1362 case 's': /* subject */
1363 format_subject(sb, msg + c->subject_off, " ");
1364 return 1;
1365 case 'f': /* sanitized subject */
1366 format_sanitized_subject(sb, msg + c->subject_off);
1367 return 1;
1368 case 'b': /* body */
1369 strbuf_addstr(sb, msg + c->body_off);
1370 return 1;
1371 }
1372
1373 if (skip_prefix(placeholder, "(trailers", &arg)) {
1374 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
1375 struct string_list filter_list = STRING_LIST_INIT_NODUP;
1376 struct strbuf sepbuf = STRBUF_INIT;
1377 size_t ret = 0;
1378
1379 opts.no_divider = 1;
1380
1381 if (*arg == ':') {
1382 arg++;
1383 for (;;) {
1384 const char *argval;
1385 size_t arglen;
1386
1387 if (match_placeholder_arg_value(arg, "key", &arg, &argval, &arglen)) {
1388 uintptr_t len = arglen;
1389
1390 if (!argval)
1391 goto trailer_out;
1392
1393 if (len && argval[len - 1] == ':')
1394 len--;
1395 string_list_append(&filter_list, argval)->util = (char *)len;
1396
1397 opts.filter = format_trailer_match_cb;
1398 opts.filter_data = &filter_list;
1399 opts.only_trailers = 1;
1400 } else if (match_placeholder_arg_value(arg, "separator", &arg, &argval, &arglen)) {
1401 char *fmt;
1402
1403 strbuf_reset(&sepbuf);
1404 fmt = xstrndup(argval, arglen);
1405 strbuf_expand(&sepbuf, fmt, strbuf_expand_literal_cb, NULL);
1406 free(fmt);
1407 opts.separator = &sepbuf;
1408 } else if (!match_placeholder_bool_arg(arg, "only", &arg, &opts.only_trailers) &&
1409 !match_placeholder_bool_arg(arg, "unfold", &arg, &opts.unfold) &&
1410 !match_placeholder_bool_arg(arg, "valueonly", &arg, &opts.value_only))
1411 break;
1412 }
1413 }
1414 if (*arg == ')') {
1415 format_trailers_from_commit(sb, msg + c->subject_off, &opts);
1416 ret = arg - placeholder + 1;
1417 }
1418 trailer_out:
1419 string_list_clear(&filter_list, 0);
1420 strbuf_release(&sepbuf);
1421 return ret;
1422 }
1423
1424 return 0; /* unknown placeholder */
1425 }
1426
1427 static size_t format_and_pad_commit(struct strbuf *sb, /* in UTF-8 */
1428 const char *placeholder,
1429 struct format_commit_context *c)
1430 {
1431 struct strbuf local_sb = STRBUF_INIT;
1432 int total_consumed = 0, len, padding = c->padding;
1433 if (padding < 0) {
1434 const char *start = strrchr(sb->buf, '\n');
1435 int occupied;
1436 if (!start)
1437 start = sb->buf;
1438 occupied = utf8_strnwidth(start, -1, 1);
1439 occupied += c->pretty_ctx->graph_width;
1440 padding = (-padding) - occupied;
1441 }
1442 while (1) {
1443 int modifier = *placeholder == 'C';
1444 int consumed = format_commit_one(&local_sb, placeholder, c);
1445 total_consumed += consumed;
1446
1447 if (!modifier)
1448 break;
1449
1450 placeholder += consumed;
1451 if (*placeholder != '%')
1452 break;
1453 placeholder++;
1454 total_consumed++;
1455 }
1456 len = utf8_strnwidth(local_sb.buf, -1, 1);
1457
1458 if (c->flush_type == flush_left_and_steal) {
1459 const char *ch = sb->buf + sb->len - 1;
1460 while (len > padding && ch > sb->buf) {
1461 const char *p;
1462 if (*ch == ' ') {
1463 ch--;
1464 padding++;
1465 continue;
1466 }
1467 /* check for trailing ansi sequences */
1468 if (*ch != 'm')
1469 break;
1470 p = ch - 1;
1471 while (ch - p < 10 && *p != '\033')
1472 p--;
1473 if (*p != '\033' ||
1474 ch + 1 - p != display_mode_esc_sequence_len(p))
1475 break;
1476 /*
1477 * got a good ansi sequence, put it back to
1478 * local_sb as we're cutting sb
1479 */
1480 strbuf_insert(&local_sb, 0, p, ch + 1 - p);
1481 ch = p - 1;
1482 }
1483 strbuf_setlen(sb, ch + 1 - sb->buf);
1484 c->flush_type = flush_left;
1485 }
1486
1487 if (len > padding) {
1488 switch (c->truncate) {
1489 case trunc_left:
1490 strbuf_utf8_replace(&local_sb,
1491 0, len - (padding - 2),
1492 "..");
1493 break;
1494 case trunc_middle:
1495 strbuf_utf8_replace(&local_sb,
1496 padding / 2 - 1,
1497 len - (padding - 2),
1498 "..");
1499 break;
1500 case trunc_right:
1501 strbuf_utf8_replace(&local_sb,
1502 padding - 2, len - (padding - 2),
1503 "..");
1504 break;
1505 case trunc_none:
1506 break;
1507 }
1508 strbuf_addbuf(sb, &local_sb);
1509 } else {
1510 int sb_len = sb->len, offset = 0;
1511 if (c->flush_type == flush_left)
1512 offset = padding - len;
1513 else if (c->flush_type == flush_both)
1514 offset = (padding - len) / 2;
1515 /*
1516 * we calculate padding in columns, now
1517 * convert it back to chars
1518 */
1519 padding = padding - len + local_sb.len;
1520 strbuf_addchars(sb, ' ', padding);
1521 memcpy(sb->buf + sb_len + offset, local_sb.buf,
1522 local_sb.len);
1523 }
1524 strbuf_release(&local_sb);
1525 c->flush_type = no_flush;
1526 return total_consumed;
1527 }
1528
1529 static size_t format_commit_item(struct strbuf *sb, /* in UTF-8 */
1530 const char *placeholder,
1531 void *context)
1532 {
1533 int consumed;
1534 size_t orig_len;
1535 enum {
1536 NO_MAGIC,
1537 ADD_LF_BEFORE_NON_EMPTY,
1538 DEL_LF_BEFORE_EMPTY,
1539 ADD_SP_BEFORE_NON_EMPTY
1540 } magic = NO_MAGIC;
1541
1542 switch (placeholder[0]) {
1543 case '-':
1544 magic = DEL_LF_BEFORE_EMPTY;
1545 break;
1546 case '+':
1547 magic = ADD_LF_BEFORE_NON_EMPTY;
1548 break;
1549 case ' ':
1550 magic = ADD_SP_BEFORE_NON_EMPTY;
1551 break;
1552 default:
1553 break;
1554 }
1555 if (magic != NO_MAGIC)
1556 placeholder++;
1557
1558 orig_len = sb->len;
1559 if (((struct format_commit_context *)context)->flush_type != no_flush)
1560 consumed = format_and_pad_commit(sb, placeholder, context);
1561 else
1562 consumed = format_commit_one(sb, placeholder, context);
1563 if (magic == NO_MAGIC)
1564 return consumed;
1565
1566 if ((orig_len == sb->len) && magic == DEL_LF_BEFORE_EMPTY) {
1567 while (sb->len && sb->buf[sb->len - 1] == '\n')
1568 strbuf_setlen(sb, sb->len - 1);
1569 } else if (orig_len != sb->len) {
1570 if (magic == ADD_LF_BEFORE_NON_EMPTY)
1571 strbuf_insert(sb, orig_len, "\n", 1);
1572 else if (magic == ADD_SP_BEFORE_NON_EMPTY)
1573 strbuf_insert(sb, orig_len, " ", 1);
1574 }
1575 return consumed + 1;
1576 }
1577
1578 static size_t userformat_want_item(struct strbuf *sb, const char *placeholder,
1579 void *context)
1580 {
1581 struct userformat_want *w = context;
1582
1583 if (*placeholder == '+' || *placeholder == '-' || *placeholder == ' ')
1584 placeholder++;
1585
1586 switch (*placeholder) {
1587 case 'N':
1588 w->notes = 1;
1589 break;
1590 case 'S':
1591 w->source = 1;
1592 break;
1593 }
1594 return 0;
1595 }
1596
1597 void userformat_find_requirements(const char *fmt, struct userformat_want *w)
1598 {
1599 struct strbuf dummy = STRBUF_INIT;
1600
1601 if (!fmt) {
1602 if (!user_format)
1603 return;
1604 fmt = user_format;
1605 }
1606 strbuf_expand(&dummy, fmt, userformat_want_item, w);
1607 strbuf_release(&dummy);
1608 }
1609
1610 void repo_format_commit_message(struct repository *r,
1611 const struct commit *commit,
1612 const char *format, struct strbuf *sb,
1613 const struct pretty_print_context *pretty_ctx)
1614 {
1615 struct format_commit_context context;
1616 const char *output_enc = pretty_ctx->output_encoding;
1617 const char *utf8 = "UTF-8";
1618
1619 memset(&context, 0, sizeof(context));
1620 context.commit = commit;
1621 context.pretty_ctx = pretty_ctx;
1622 context.wrap_start = sb->len;
1623 /*
1624 * convert a commit message to UTF-8 first
1625 * as far as 'format_commit_item' assumes it in UTF-8
1626 */
1627 context.message = repo_logmsg_reencode(r, commit,
1628 &context.commit_encoding,
1629 utf8);
1630
1631 strbuf_expand(sb, format, format_commit_item, &context);
1632 rewrap_message_tail(sb, &context, 0, 0, 0);
1633
1634 /* then convert a commit message to an actual output encoding */
1635 if (output_enc) {
1636 if (same_encoding(utf8, output_enc))
1637 output_enc = NULL;
1638 } else {
1639 if (context.commit_encoding &&
1640 !same_encoding(context.commit_encoding, utf8))
1641 output_enc = context.commit_encoding;
1642 }
1643
1644 if (output_enc) {
1645 size_t outsz;
1646 char *out = reencode_string_len(sb->buf, sb->len,
1647 output_enc, utf8, &outsz);
1648 if (out)
1649 strbuf_attach(sb, out, outsz, outsz + 1);
1650 }
1651
1652 free(context.commit_encoding);
1653 repo_unuse_commit_buffer(r, commit, context.message);
1654 }
1655
1656 static void pp_header(struct pretty_print_context *pp,
1657 const char *encoding,
1658 const struct commit *commit,
1659 const char **msg_p,
1660 struct strbuf *sb)
1661 {
1662 int parents_shown = 0;
1663
1664 for (;;) {
1665 const char *name, *line = *msg_p;
1666 int linelen = get_one_line(*msg_p);
1667
1668 if (!linelen)
1669 return;
1670 *msg_p += linelen;
1671
1672 if (linelen == 1)
1673 /* End of header */
1674 return;
1675
1676 if (pp->fmt == CMIT_FMT_RAW) {
1677 strbuf_add(sb, line, linelen);
1678 continue;
1679 }
1680
1681 if (starts_with(line, "parent ")) {
1682 if (linelen != the_hash_algo->hexsz + 8)
1683 die("bad parent line in commit");
1684 continue;
1685 }
1686
1687 if (!parents_shown) {
1688 unsigned num = commit_list_count(commit->parents);
1689 /* with enough slop */
1690 strbuf_grow(sb, num * (GIT_MAX_HEXSZ + 10) + 20);
1691 add_merge_info(pp, sb, commit);
1692 parents_shown = 1;
1693 }
1694
1695 /*
1696 * MEDIUM == DEFAULT shows only author with dates.
1697 * FULL shows both authors but not dates.
1698 * FULLER shows both authors and dates.
1699 */
1700 if (skip_prefix(line, "author ", &name)) {
1701 strbuf_grow(sb, linelen + 80);
1702 pp_user_info(pp, "Author", sb, name, encoding);
1703 }
1704 if (skip_prefix(line, "committer ", &name) &&
1705 (pp->fmt == CMIT_FMT_FULL || pp->fmt == CMIT_FMT_FULLER)) {
1706 strbuf_grow(sb, linelen + 80);
1707 pp_user_info(pp, "Commit", sb, name, encoding);
1708 }
1709 }
1710 }
1711
1712 void pp_title_line(struct pretty_print_context *pp,
1713 const char **msg_p,
1714 struct strbuf *sb,
1715 const char *encoding,
1716 int need_8bit_cte)
1717 {
1718 static const int max_length = 78; /* per rfc2047 */
1719 struct strbuf title;
1720
1721 strbuf_init(&title, 80);
1722 *msg_p = format_subject(&title, *msg_p,
1723 pp->preserve_subject ? "\n" : " ");
1724
1725 strbuf_grow(sb, title.len + 1024);
1726 if (pp->print_email_subject) {
1727 if (pp->rev)
1728 fmt_output_email_subject(sb, pp->rev);
1729 if (needs_rfc2047_encoding(title.buf, title.len))
1730 add_rfc2047(sb, title.buf, title.len,
1731 encoding, RFC2047_SUBJECT);
1732 else
1733 strbuf_add_wrapped_bytes(sb, title.buf, title.len,
1734 -last_line_length(sb), 1, max_length);
1735 } else {
1736 strbuf_addbuf(sb, &title);
1737 }
1738 strbuf_addch(sb, '\n');
1739
1740 if (need_8bit_cte == 0) {
1741 int i;
1742 for (i = 0; i < pp->in_body_headers.nr; i++) {
1743 if (has_non_ascii(pp->in_body_headers.items[i].string)) {
1744 need_8bit_cte = 1;
1745 break;
1746 }
1747 }
1748 }
1749
1750 if (need_8bit_cte > 0) {
1751 const char *header_fmt =
1752 "MIME-Version: 1.0\n"
1753 "Content-Type: text/plain; charset=%s\n"
1754 "Content-Transfer-Encoding: 8bit\n";
1755 strbuf_addf(sb, header_fmt, encoding);
1756 }
1757 if (pp->after_subject) {
1758 strbuf_addstr(sb, pp->after_subject);
1759 }
1760 if (cmit_fmt_is_mail(pp->fmt)) {
1761 strbuf_addch(sb, '\n');
1762 }
1763
1764 if (pp->in_body_headers.nr) {
1765 int i;
1766 for (i = 0; i < pp->in_body_headers.nr; i++) {
1767 strbuf_addstr(sb, pp->in_body_headers.items[i].string);
1768 free(pp->in_body_headers.items[i].string);
1769 }
1770 string_list_clear(&pp->in_body_headers, 0);
1771 strbuf_addch(sb, '\n');
1772 }
1773
1774 strbuf_release(&title);
1775 }
1776
1777 static int pp_utf8_width(const char *start, const char *end)
1778 {
1779 int width = 0;
1780 size_t remain = end - start;
1781
1782 while (remain) {
1783 int n = utf8_width(&start, &remain);
1784 if (n < 0 || !start)
1785 return -1;
1786 width += n;
1787 }
1788 return width;
1789 }
1790
1791 static void strbuf_add_tabexpand(struct strbuf *sb, int tabwidth,
1792 const char *line, int linelen)
1793 {
1794 const char *tab;
1795
1796 while ((tab = memchr(line, '\t', linelen)) != NULL) {
1797 int width = pp_utf8_width(line, tab);
1798
1799 /*
1800 * If it wasn't well-formed utf8, or it
1801 * had characters with badly defined
1802 * width (control characters etc), just
1803 * give up on trying to align things.
1804 */
1805 if (width < 0)
1806 break;
1807
1808 /* Output the data .. */
1809 strbuf_add(sb, line, tab - line);
1810
1811 /* .. and the de-tabified tab */
1812 strbuf_addchars(sb, ' ', tabwidth - (width % tabwidth));
1813
1814 /* Skip over the printed part .. */
1815 linelen -= tab + 1 - line;
1816 line = tab + 1;
1817 }
1818
1819 /*
1820 * Print out everything after the last tab without
1821 * worrying about width - there's nothing more to
1822 * align.
1823 */
1824 strbuf_add(sb, line, linelen);
1825 }
1826
1827 /*
1828 * pp_handle_indent() prints out the intendation, and
1829 * the whole line (without the final newline), after
1830 * de-tabifying.
1831 */
1832 static void pp_handle_indent(struct pretty_print_context *pp,
1833 struct strbuf *sb, int indent,
1834 const char *line, int linelen)
1835 {
1836 strbuf_addchars(sb, ' ', indent);
1837 if (pp->expand_tabs_in_log)
1838 strbuf_add_tabexpand(sb, pp->expand_tabs_in_log, line, linelen);
1839 else
1840 strbuf_add(sb, line, linelen);
1841 }
1842
1843 static int is_mboxrd_from(const char *line, int len)
1844 {
1845 /*
1846 * a line matching /^From $/ here would only have len == 4
1847 * at this point because is_empty_line would've trimmed all
1848 * trailing space
1849 */
1850 return len > 4 && starts_with(line + strspn(line, ">"), "From ");
1851 }
1852
1853 void pp_remainder(struct pretty_print_context *pp,
1854 const char **msg_p,
1855 struct strbuf *sb,
1856 int indent)
1857 {
1858 int first = 1;
1859 for (;;) {
1860 const char *line = *msg_p;
1861 int linelen = get_one_line(line);
1862 *msg_p += linelen;
1863
1864 if (!linelen)
1865 break;
1866
1867 if (is_blank_line(line, &linelen)) {
1868 if (first)
1869 continue;
1870 if (pp->fmt == CMIT_FMT_SHORT)
1871 break;
1872 }
1873 first = 0;
1874
1875 strbuf_grow(sb, linelen + indent + 20);
1876 if (indent)
1877 pp_handle_indent(pp, sb, indent, line, linelen);
1878 else if (pp->expand_tabs_in_log)
1879 strbuf_add_tabexpand(sb, pp->expand_tabs_in_log,
1880 line, linelen);
1881 else {
1882 if (pp->fmt == CMIT_FMT_MBOXRD &&
1883 is_mboxrd_from(line, linelen))
1884 strbuf_addch(sb, '>');
1885
1886 strbuf_add(sb, line, linelen);
1887 }
1888 strbuf_addch(sb, '\n');
1889 }
1890 }
1891
1892 void pretty_print_commit(struct pretty_print_context *pp,
1893 const struct commit *commit,
1894 struct strbuf *sb)
1895 {
1896 unsigned long beginning_of_body;
1897 int indent = 4;
1898 const char *msg;
1899 const char *reencoded;
1900 const char *encoding;
1901 int need_8bit_cte = pp->need_8bit_cte;
1902
1903 if (pp->fmt == CMIT_FMT_USERFORMAT) {
1904 format_commit_message(commit, user_format, sb, pp);
1905 return;
1906 }
1907
1908 encoding = get_log_output_encoding();
1909 msg = reencoded = logmsg_reencode(commit, NULL, encoding);
1910
1911 if (pp->fmt == CMIT_FMT_ONELINE || cmit_fmt_is_mail(pp->fmt))
1912 indent = 0;
1913
1914 /*
1915 * We need to check and emit Content-type: to mark it
1916 * as 8-bit if we haven't done so.
1917 */
1918 if (cmit_fmt_is_mail(pp->fmt) && need_8bit_cte == 0) {
1919 int i, ch, in_body;
1920
1921 for (in_body = i = 0; (ch = msg[i]); i++) {
1922 if (!in_body) {
1923 /* author could be non 7-bit ASCII but
1924 * the log may be so; skip over the
1925 * header part first.
1926 */
1927 if (ch == '\n' && msg[i+1] == '\n')
1928 in_body = 1;
1929 }
1930 else if (non_ascii(ch)) {
1931 need_8bit_cte = 1;
1932 break;
1933 }
1934 }
1935 }
1936
1937 pp_header(pp, encoding, commit, &msg, sb);
1938 if (pp->fmt != CMIT_FMT_ONELINE && !pp->print_email_subject) {
1939 strbuf_addch(sb, '\n');
1940 }
1941
1942 /* Skip excess blank lines at the beginning of body, if any... */
1943 msg = skip_blank_lines(msg);
1944
1945 /* These formats treat the title line specially. */
1946 if (pp->fmt == CMIT_FMT_ONELINE || cmit_fmt_is_mail(pp->fmt))
1947 pp_title_line(pp, &msg, sb, encoding, need_8bit_cte);
1948
1949 beginning_of_body = sb->len;
1950 if (pp->fmt != CMIT_FMT_ONELINE)
1951 pp_remainder(pp, &msg, sb, indent);
1952 strbuf_rtrim(sb);
1953
1954 /* Make sure there is an EOLN for the non-oneline case */
1955 if (pp->fmt != CMIT_FMT_ONELINE)
1956 strbuf_addch(sb, '\n');
1957
1958 /*
1959 * The caller may append additional body text in e-mail
1960 * format. Make sure we did not strip the blank line
1961 * between the header and the body.
1962 */
1963 if (cmit_fmt_is_mail(pp->fmt) && sb->len <= beginning_of_body)
1964 strbuf_addch(sb, '\n');
1965
1966 unuse_commit_buffer(commit, reencoded);
1967 }
1968
1969 void pp_commit_easy(enum cmit_fmt fmt, const struct commit *commit,
1970 struct strbuf *sb)
1971 {
1972 struct pretty_print_context pp = {0};
1973 pp.fmt = fmt;
1974 pretty_print_commit(&pp, commit, sb);
1975 }
The Best VCS Around