?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sha1-file: document how to use pretend_object_file
[git/debian.git] / pretty.c
blobb32f0369531c6f14799329890880600e714e6b4b
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') /* 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 format_decorations(sb, commit, c->auto_color);
1243 return 1;
1244 case 'D':
1245 format_decorations_extended(sb, commit, c->auto_color, "", ", ", "");
1246 return 1;
1247 case 'S': /* tag/branch like --source */
1248 if (!(c->pretty_ctx->rev && c->pretty_ctx->rev->sources))
1249 return 0;
1250 slot = revision_sources_at(c->pretty_ctx->rev->sources, commit);
1251 if (!(slot && *slot))
1252 return 0;
1253 strbuf_addstr(sb, *slot);
1254 return 1;
1255 case 'g': /* reflog info */
1256 switch(placeholder[1]) {
1257 case 'd': /* reflog selector */
1258 case 'D':
1259 if (c->pretty_ctx->reflog_info)
1260 get_reflog_selector(sb,
1261 c->pretty_ctx->reflog_info,
1262 &c->pretty_ctx->date_mode,
1263 c->pretty_ctx->date_mode_explicit,
1264 (placeholder[1] == 'd'));
1265 return 2;
1266 case 's': /* reflog message */
1267 if (c->pretty_ctx->reflog_info)
1268 get_reflog_message(sb, c->pretty_ctx->reflog_info);
1269 return 2;
1270 case 'n':
1271 case 'N':
1272 case 'e':
1273 case 'E':
1274 return format_reflog_person(sb,
1275 placeholder[1],
1276 c->pretty_ctx->reflog_info,
1277 &c->pretty_ctx->date_mode);
1278 }
1279 return 0; /* unknown %g placeholder */
1280 case 'N':
1281 if (c->pretty_ctx->notes_message) {
1282 strbuf_addstr(sb, c->pretty_ctx->notes_message);
1283 return 1;
1284 }
1285 return 0;
1286 }
1287
1288 if (placeholder[0] == 'G') {
1289 if (!c->signature_check.result)
1290 check_commit_signature(c->commit, &(c->signature_check));
1291 switch (placeholder[1]) {
1292 case 'G':
1293 if (c->signature_check.gpg_output)
1294 strbuf_addstr(sb, c->signature_check.gpg_output);
1295 break;
1296 case '?':
1297 switch (c->signature_check.result) {
1298 case 'G':
1299 case 'B':
1300 case 'E':
1301 case 'U':
1302 case 'N':
1303 case 'X':
1304 case 'Y':
1305 case 'R':
1306 strbuf_addch(sb, c->signature_check.result);
1307 }
1308 break;
1309 case 'S':
1310 if (c->signature_check.signer)
1311 strbuf_addstr(sb, c->signature_check.signer);
1312 break;
1313 case 'K':
1314 if (c->signature_check.key)
1315 strbuf_addstr(sb, c->signature_check.key);
1316 break;
1317 case 'F':
1318 if (c->signature_check.fingerprint)
1319 strbuf_addstr(sb, c->signature_check.fingerprint);
1320 break;
1321 case 'P':
1322 if (c->signature_check.primary_key_fingerprint)
1323 strbuf_addstr(sb, c->signature_check.primary_key_fingerprint);
1324 break;
1325 default:
1326 return 0;
1327 }
1328 return 2;
1329 }
1330
1331
1332 /* For the rest we have to parse the commit header. */
1333 if (!c->commit_header_parsed)
1334 parse_commit_header(c);
1335
1336 switch (placeholder[0]) {
1337 case 'a': /* author ... */
1338 return format_person_part(sb, placeholder[1],
1339 msg + c->author.off, c->author.len,
1340 &c->pretty_ctx->date_mode);
1341 case 'c': /* committer ... */
1342 return format_person_part(sb, placeholder[1],
1343 msg + c->committer.off, c->committer.len,
1344 &c->pretty_ctx->date_mode);
1345 case 'e': /* encoding */
1346 if (c->commit_encoding)
1347 strbuf_addstr(sb, c->commit_encoding);
1348 return 1;
1349 case 'B': /* raw body */
1350 /* message_off is always left at the initial newline */
1351 strbuf_addstr(sb, msg + c->message_off + 1);
1352 return 1;
1353 }
1354
1355 /* Now we need to parse the commit message. */
1356 if (!c->commit_message_parsed)
1357 parse_commit_message(c);
1358
1359 switch (placeholder[0]) {
1360 case 's': /* subject */
1361 format_subject(sb, msg + c->subject_off, " ");
1362 return 1;
1363 case 'f': /* sanitized subject */
1364 format_sanitized_subject(sb, msg + c->subject_off);
1365 return 1;
1366 case 'b': /* body */
1367 strbuf_addstr(sb, msg + c->body_off);
1368 return 1;
1369 }
1370
1371 if (skip_prefix(placeholder, "(trailers", &arg)) {
1372 struct process_trailer_options opts = PROCESS_TRAILER_OPTIONS_INIT;
1373 struct string_list filter_list = STRING_LIST_INIT_NODUP;
1374 struct strbuf sepbuf = STRBUF_INIT;
1375 size_t ret = 0;
1376
1377 opts.no_divider = 1;
1378
1379 if (*arg == ':') {
1380 arg++;
1381 for (;;) {
1382 const char *argval;
1383 size_t arglen;
1384
1385 if (match_placeholder_arg_value(arg, "key", &arg, &argval, &arglen)) {
1386 uintptr_t len = arglen;
1387
1388 if (!argval)
1389 goto trailer_out;
1390
1391 if (len && argval[len - 1] == ':')
1392 len--;
1393 string_list_append(&filter_list, argval)->util = (char *)len;
1394
1395 opts.filter = format_trailer_match_cb;
1396 opts.filter_data = &filter_list;
1397 opts.only_trailers = 1;
1398 } else if (match_placeholder_arg_value(arg, "separator", &arg, &argval, &arglen)) {
1399 char *fmt;
1400
1401 strbuf_reset(&sepbuf);
1402 fmt = xstrndup(argval, arglen);
1403 strbuf_expand(&sepbuf, fmt, strbuf_expand_literal_cb, NULL);
1404 free(fmt);
1405 opts.separator = &sepbuf;
1406 } else if (!match_placeholder_bool_arg(arg, "only", &arg, &opts.only_trailers) &&
1407 !match_placeholder_bool_arg(arg, "unfold", &arg, &opts.unfold) &&
1408 !match_placeholder_bool_arg(arg, "valueonly", &arg, &opts.value_only))
1409 break;
1410 }
1411 }
1412 if (*arg == ')') {
1413 format_trailers_from_commit(sb, msg + c->subject_off, &opts);
1414 ret = arg - placeholder + 1;
1415 }
1416 trailer_out:
1417 string_list_clear(&filter_list, 0);
1418 strbuf_release(&sepbuf);
1419 return ret;
1420 }
1421
1422 return 0; /* unknown placeholder */
1423 }
1424
1425 static size_t format_and_pad_commit(struct strbuf *sb, /* in UTF-8 */
1426 const char *placeholder,
1427 struct format_commit_context *c)
1428 {
1429 struct strbuf local_sb = STRBUF_INIT;
1430 int total_consumed = 0, len, padding = c->padding;
1431 if (padding < 0) {
1432 const char *start = strrchr(sb->buf, '\n');
1433 int occupied;
1434 if (!start)
1435 start = sb->buf;
1436 occupied = utf8_strnwidth(start, -1, 1);
1437 occupied += c->pretty_ctx->graph_width;
1438 padding = (-padding) - occupied;
1439 }
1440 while (1) {
1441 int modifier = *placeholder == 'C';
1442 int consumed = format_commit_one(&local_sb, placeholder, c);
1443 total_consumed += consumed;
1444
1445 if (!modifier)
1446 break;
1447
1448 placeholder += consumed;
1449 if (*placeholder != '%')
1450 break;
1451 placeholder++;
1452 total_consumed++;
1453 }
1454 len = utf8_strnwidth(local_sb.buf, -1, 1);
1455
1456 if (c->flush_type == flush_left_and_steal) {
1457 const char *ch = sb->buf + sb->len - 1;
1458 while (len > padding && ch > sb->buf) {
1459 const char *p;
1460 if (*ch == ' ') {
1461 ch--;
1462 padding++;
1463 continue;
1464 }
1465 /* check for trailing ansi sequences */
1466 if (*ch != 'm')
1467 break;
1468 p = ch - 1;
1469 while (ch - p < 10 && *p != '\033')
1470 p--;
1471 if (*p != '\033' ||
1472 ch + 1 - p != display_mode_esc_sequence_len(p))
1473 break;
1474 /*
1475 * got a good ansi sequence, put it back to
1476 * local_sb as we're cutting sb
1477 */
1478 strbuf_insert(&local_sb, 0, p, ch + 1 - p);
1479 ch = p - 1;
1480 }
1481 strbuf_setlen(sb, ch + 1 - sb->buf);
1482 c->flush_type = flush_left;
1483 }
1484
1485 if (len > padding) {
1486 switch (c->truncate) {
1487 case trunc_left:
1488 strbuf_utf8_replace(&local_sb,
1489 0, len - (padding - 2),
1490 "..");
1491 break;
1492 case trunc_middle:
1493 strbuf_utf8_replace(&local_sb,
1494 padding / 2 - 1,
1495 len - (padding - 2),
1496 "..");
1497 break;
1498 case trunc_right:
1499 strbuf_utf8_replace(&local_sb,
1500 padding - 2, len - (padding - 2),
1501 "..");
1502 break;
1503 case trunc_none:
1504 break;
1505 }
1506 strbuf_addbuf(sb, &local_sb);
1507 } else {
1508 int sb_len = sb->len, offset = 0;
1509 if (c->flush_type == flush_left)
1510 offset = padding - len;
1511 else if (c->flush_type == flush_both)
1512 offset = (padding - len) / 2;
1513 /*
1514 * we calculate padding in columns, now
1515 * convert it back to chars
1516 */
1517 padding = padding - len + local_sb.len;
1518 strbuf_addchars(sb, ' ', padding);
1519 memcpy(sb->buf + sb_len + offset, local_sb.buf,
1520 local_sb.len);
1521 }
1522 strbuf_release(&local_sb);
1523 c->flush_type = no_flush;
1524 return total_consumed;
1525 }
1526
1527 static size_t format_commit_item(struct strbuf *sb, /* in UTF-8 */
1528 const char *placeholder,
1529 void *context)
1530 {
1531 int consumed;
1532 size_t orig_len;
1533 enum {
1534 NO_MAGIC,
1535 ADD_LF_BEFORE_NON_EMPTY,
1536 DEL_LF_BEFORE_EMPTY,
1537 ADD_SP_BEFORE_NON_EMPTY
1538 } magic = NO_MAGIC;
1539
1540 switch (placeholder[0]) {
1541 case '-':
1542 magic = DEL_LF_BEFORE_EMPTY;
1543 break;
1544 case '+':
1545 magic = ADD_LF_BEFORE_NON_EMPTY;
1546 break;
1547 case ' ':
1548 magic = ADD_SP_BEFORE_NON_EMPTY;
1549 break;
1550 default:
1551 break;
1552 }
1553 if (magic != NO_MAGIC)
1554 placeholder++;
1555
1556 orig_len = sb->len;
1557 if (((struct format_commit_context *)context)->flush_type != no_flush)
1558 consumed = format_and_pad_commit(sb, placeholder, context);
1559 else
1560 consumed = format_commit_one(sb, placeholder, context);
1561 if (magic == NO_MAGIC)
1562 return consumed;
1563
1564 if ((orig_len == sb->len) && magic == DEL_LF_BEFORE_EMPTY) {
1565 while (sb->len && sb->buf[sb->len - 1] == '\n')
1566 strbuf_setlen(sb, sb->len - 1);
1567 } else if (orig_len != sb->len) {
1568 if (magic == ADD_LF_BEFORE_NON_EMPTY)
1569 strbuf_insert(sb, orig_len, "\n", 1);
1570 else if (magic == ADD_SP_BEFORE_NON_EMPTY)
1571 strbuf_insert(sb, orig_len, " ", 1);
1572 }
1573 return consumed + 1;
1574 }
1575
1576 static size_t userformat_want_item(struct strbuf *sb, const char *placeholder,
1577 void *context)
1578 {
1579 struct userformat_want *w = context;
1580
1581 if (*placeholder == '+' || *placeholder == '-' || *placeholder == ' ')
1582 placeholder++;
1583
1584 switch (*placeholder) {
1585 case 'N':
1586 w->notes = 1;
1587 break;
1588 case 'S':
1589 w->source = 1;
1590 break;
1591 }
1592 return 0;
1593 }
1594
1595 void userformat_find_requirements(const char *fmt, struct userformat_want *w)
1596 {
1597 struct strbuf dummy = STRBUF_INIT;
1598
1599 if (!fmt) {
1600 if (!user_format)
1601 return;
1602 fmt = user_format;
1603 }
1604 strbuf_expand(&dummy, fmt, userformat_want_item, w);
1605 strbuf_release(&dummy);
1606 }
1607
1608 void repo_format_commit_message(struct repository *r,
1609 const struct commit *commit,
1610 const char *format, struct strbuf *sb,
1611 const struct pretty_print_context *pretty_ctx)
1612 {
1613 struct format_commit_context context;
1614 const char *output_enc = pretty_ctx->output_encoding;
1615 const char *utf8 = "UTF-8";
1616
1617 memset(&context, 0, sizeof(context));
1618 context.commit = commit;
1619 context.pretty_ctx = pretty_ctx;
1620 context.wrap_start = sb->len;
1621 /*
1622 * convert a commit message to UTF-8 first
1623 * as far as 'format_commit_item' assumes it in UTF-8
1624 */
1625 context.message = repo_logmsg_reencode(r, commit,
1626 &context.commit_encoding,
1627 utf8);
1628
1629 strbuf_expand(sb, format, format_commit_item, &context);
1630 rewrap_message_tail(sb, &context, 0, 0, 0);
1631
1632 /* then convert a commit message to an actual output encoding */
1633 if (output_enc) {
1634 if (same_encoding(utf8, output_enc))
1635 output_enc = NULL;
1636 } else {
1637 if (context.commit_encoding &&
1638 !same_encoding(context.commit_encoding, utf8))
1639 output_enc = context.commit_encoding;
1640 }
1641
1642 if (output_enc) {
1643 size_t outsz;
1644 char *out = reencode_string_len(sb->buf, sb->len,
1645 output_enc, utf8, &outsz);
1646 if (out)
1647 strbuf_attach(sb, out, outsz, outsz + 1);
1648 }
1649
1650 free(context.commit_encoding);
1651 repo_unuse_commit_buffer(r, commit, context.message);
1652 }
1653
1654 static void pp_header(struct pretty_print_context *pp,
1655 const char *encoding,
1656 const struct commit *commit,
1657 const char **msg_p,
1658 struct strbuf *sb)
1659 {
1660 int parents_shown = 0;
1661
1662 for (;;) {
1663 const char *name, *line = *msg_p;
1664 int linelen = get_one_line(*msg_p);
1665
1666 if (!linelen)
1667 return;
1668 *msg_p += linelen;
1669
1670 if (linelen == 1)
1671 /* End of header */
1672 return;
1673
1674 if (pp->fmt == CMIT_FMT_RAW) {
1675 strbuf_add(sb, line, linelen);
1676 continue;
1677 }
1678
1679 if (starts_with(line, "parent ")) {
1680 if (linelen != the_hash_algo->hexsz + 8)
1681 die("bad parent line in commit");
1682 continue;
1683 }
1684
1685 if (!parents_shown) {
1686 unsigned num = commit_list_count(commit->parents);
1687 /* with enough slop */
1688 strbuf_grow(sb, num * (GIT_MAX_HEXSZ + 10) + 20);
1689 add_merge_info(pp, sb, commit);
1690 parents_shown = 1;
1691 }
1692
1693 /*
1694 * MEDIUM == DEFAULT shows only author with dates.
1695 * FULL shows both authors but not dates.
1696 * FULLER shows both authors and dates.
1697 */
1698 if (skip_prefix(line, "author ", &name)) {
1699 strbuf_grow(sb, linelen + 80);
1700 pp_user_info(pp, "Author", sb, name, encoding);
1701 }
1702 if (skip_prefix(line, "committer ", &name) &&
1703 (pp->fmt == CMIT_FMT_FULL || pp->fmt == CMIT_FMT_FULLER)) {
1704 strbuf_grow(sb, linelen + 80);
1705 pp_user_info(pp, "Commit", sb, name, encoding);
1706 }
1707 }
1708 }
1709
1710 void pp_title_line(struct pretty_print_context *pp,
1711 const char **msg_p,
1712 struct strbuf *sb,
1713 const char *encoding,
1714 int need_8bit_cte)
1715 {
1716 static const int max_length = 78; /* per rfc2047 */
1717 struct strbuf title;
1718
1719 strbuf_init(&title, 80);
1720 *msg_p = format_subject(&title, *msg_p,
1721 pp->preserve_subject ? "\n" : " ");
1722
1723 strbuf_grow(sb, title.len + 1024);
1724 if (pp->print_email_subject) {
1725 if (pp->rev)
1726 fmt_output_email_subject(sb, pp->rev);
1727 if (needs_rfc2047_encoding(title.buf, title.len))
1728 add_rfc2047(sb, title.buf, title.len,
1729 encoding, RFC2047_SUBJECT);
1730 else
1731 strbuf_add_wrapped_bytes(sb, title.buf, title.len,
1732 -last_line_length(sb), 1, max_length);
1733 } else {
1734 strbuf_addbuf(sb, &title);
1735 }
1736 strbuf_addch(sb, '\n');
1737
1738 if (need_8bit_cte == 0) {
1739 int i;
1740 for (i = 0; i < pp->in_body_headers.nr; i++) {
1741 if (has_non_ascii(pp->in_body_headers.items[i].string)) {
1742 need_8bit_cte = 1;
1743 break;
1744 }
1745 }
1746 }
1747
1748 if (need_8bit_cte > 0) {
1749 const char *header_fmt =
1750 "MIME-Version: 1.0\n"
1751 "Content-Type: text/plain; charset=%s\n"
1752 "Content-Transfer-Encoding: 8bit\n";
1753 strbuf_addf(sb, header_fmt, encoding);
1754 }
1755 if (pp->after_subject) {
1756 strbuf_addstr(sb, pp->after_subject);
1757 }
1758 if (cmit_fmt_is_mail(pp->fmt)) {
1759 strbuf_addch(sb, '\n');
1760 }
1761
1762 if (pp->in_body_headers.nr) {
1763 int i;
1764 for (i = 0; i < pp->in_body_headers.nr; i++) {
1765 strbuf_addstr(sb, pp->in_body_headers.items[i].string);
1766 free(pp->in_body_headers.items[i].string);
1767 }
1768 string_list_clear(&pp->in_body_headers, 0);
1769 strbuf_addch(sb, '\n');
1770 }
1771
1772 strbuf_release(&title);
1773 }
1774
1775 static int pp_utf8_width(const char *start, const char *end)
1776 {
1777 int width = 0;
1778 size_t remain = end - start;
1779
1780 while (remain) {
1781 int n = utf8_width(&start, &remain);
1782 if (n < 0 || !start)
1783 return -1;
1784 width += n;
1785 }
1786 return width;
1787 }
1788
1789 static void strbuf_add_tabexpand(struct strbuf *sb, int tabwidth,
1790 const char *line, int linelen)
1791 {
1792 const char *tab;
1793
1794 while ((tab = memchr(line, '\t', linelen)) != NULL) {
1795 int width = pp_utf8_width(line, tab);
1796
1797 /*
1798 * If it wasn't well-formed utf8, or it
1799 * had characters with badly defined
1800 * width (control characters etc), just
1801 * give up on trying to align things.
1802 */
1803 if (width < 0)
1804 break;
1805
1806 /* Output the data .. */
1807 strbuf_add(sb, line, tab - line);
1808
1809 /* .. and the de-tabified tab */
1810 strbuf_addchars(sb, ' ', tabwidth - (width % tabwidth));
1811
1812 /* Skip over the printed part .. */
1813 linelen -= tab + 1 - line;
1814 line = tab + 1;
1815 }
1816
1817 /*
1818 * Print out everything after the last tab without
1819 * worrying about width - there's nothing more to
1820 * align.
1821 */
1822 strbuf_add(sb, line, linelen);
1823 }
1824
1825 /*
1826 * pp_handle_indent() prints out the intendation, and
1827 * the whole line (without the final newline), after
1828 * de-tabifying.
1829 */
1830 static void pp_handle_indent(struct pretty_print_context *pp,
1831 struct strbuf *sb, int indent,
1832 const char *line, int linelen)
1833 {
1834 strbuf_addchars(sb, ' ', indent);
1835 if (pp->expand_tabs_in_log)
1836 strbuf_add_tabexpand(sb, pp->expand_tabs_in_log, line, linelen);
1837 else
1838 strbuf_add(sb, line, linelen);
1839 }
1840
1841 static int is_mboxrd_from(const char *line, int len)
1842 {
1843 /*
1844 * a line matching /^From $/ here would only have len == 4
1845 * at this point because is_empty_line would've trimmed all
1846 * trailing space
1847 */
1848 return len > 4 && starts_with(line + strspn(line, ">"), "From ");
1849 }
1850
1851 void pp_remainder(struct pretty_print_context *pp,
1852 const char **msg_p,
1853 struct strbuf *sb,
1854 int indent)
1855 {
1856 int first = 1;
1857 for (;;) {
1858 const char *line = *msg_p;
1859 int linelen = get_one_line(line);
1860 *msg_p += linelen;
1861
1862 if (!linelen)
1863 break;
1864
1865 if (is_blank_line(line, &linelen)) {
1866 if (first)
1867 continue;
1868 if (pp->fmt == CMIT_FMT_SHORT)
1869 break;
1870 }
1871 first = 0;
1872
1873 strbuf_grow(sb, linelen + indent + 20);
1874 if (indent)
1875 pp_handle_indent(pp, sb, indent, line, linelen);
1876 else if (pp->expand_tabs_in_log)
1877 strbuf_add_tabexpand(sb, pp->expand_tabs_in_log,
1878 line, linelen);
1879 else {
1880 if (pp->fmt == CMIT_FMT_MBOXRD &&
1881 is_mboxrd_from(line, linelen))
1882 strbuf_addch(sb, '>');
1883
1884 strbuf_add(sb, line, linelen);
1885 }
1886 strbuf_addch(sb, '\n');
1887 }
1888 }
1889
1890 void pretty_print_commit(struct pretty_print_context *pp,
1891 const struct commit *commit,
1892 struct strbuf *sb)
1893 {
1894 unsigned long beginning_of_body;
1895 int indent = 4;
1896 const char *msg;
1897 const char *reencoded;
1898 const char *encoding;
1899 int need_8bit_cte = pp->need_8bit_cte;
1900
1901 if (pp->fmt == CMIT_FMT_USERFORMAT) {
1902 format_commit_message(commit, user_format, sb, pp);
1903 return;
1904 }
1905
1906 encoding = get_log_output_encoding();
1907 msg = reencoded = logmsg_reencode(commit, NULL, encoding);
1908
1909 if (pp->fmt == CMIT_FMT_ONELINE || cmit_fmt_is_mail(pp->fmt))
1910 indent = 0;
1911
1912 /*
1913 * We need to check and emit Content-type: to mark it
1914 * as 8-bit if we haven't done so.
1915 */
1916 if (cmit_fmt_is_mail(pp->fmt) && need_8bit_cte == 0) {
1917 int i, ch, in_body;
1918
1919 for (in_body = i = 0; (ch = msg[i]); i++) {
1920 if (!in_body) {
1921 /* author could be non 7-bit ASCII but
1922 * the log may be so; skip over the
1923 * header part first.
1924 */
1925 if (ch == '\n' && msg[i+1] == '\n')
1926 in_body = 1;
1927 }
1928 else if (non_ascii(ch)) {
1929 need_8bit_cte = 1;
1930 break;
1931 }
1932 }
1933 }
1934
1935 pp_header(pp, encoding, commit, &msg, sb);
1936 if (pp->fmt != CMIT_FMT_ONELINE && !pp->print_email_subject) {
1937 strbuf_addch(sb, '\n');
1938 }
1939
1940 /* Skip excess blank lines at the beginning of body, if any... */
1941 msg = skip_blank_lines(msg);
1942
1943 /* These formats treat the title line specially. */
1944 if (pp->fmt == CMIT_FMT_ONELINE || cmit_fmt_is_mail(pp->fmt))
1945 pp_title_line(pp, &msg, sb, encoding, need_8bit_cte);
1946
1947 beginning_of_body = sb->len;
1948 if (pp->fmt != CMIT_FMT_ONELINE)
1949 pp_remainder(pp, &msg, sb, indent);
1950 strbuf_rtrim(sb);
1951
1952 /* Make sure there is an EOLN for the non-oneline case */
1953 if (pp->fmt != CMIT_FMT_ONELINE)
1954 strbuf_addch(sb, '\n');
1955
1956 /*
1957 * The caller may append additional body text in e-mail
1958 * format. Make sure we did not strip the blank line
1959 * between the header and the body.
1960 */
1961 if (cmit_fmt_is_mail(pp->fmt) && sb->len <= beginning_of_body)
1962 strbuf_addch(sb, '\n');
1963
1964 unuse_commit_buffer(commit, reencoded);
1965 }
1966
1967 void pp_commit_easy(enum cmit_fmt fmt, const struct commit *commit,
1968 struct strbuf *sb)
1969 {
1970 struct pretty_print_context pp = {0};
1971 pp.fmt = fmt;
1972 pretty_print_commit(&pp, commit, sb);
1973 }
git for Debian