Merge branch 'vr/merge-base-doc'
[git] / pretty.c
1 #include "cache.h"
2 #include "commit.h"
3 #include "utf8.h"
4 #include "diff.h"
5 #include "revision.h"
6 #include "string-list.h"
7 #include "mailmap.h"
8 #include "log-tree.h"
9 #include "notes.h"
10 #include "color.h"
11 #include "reflog-walk.h"
12
13 static char *user_format;
14 static struct cmt_fmt_map {
15         const char *name;
16         enum cmit_fmt format;
17         int is_tformat;
18         int is_alias;
19         const char *user_format;
20 } *commit_formats;
21 static size_t builtin_formats_len;
22 static size_t commit_formats_len;
23 static size_t commit_formats_alloc;
24 static struct cmt_fmt_map *find_commit_format(const char *sought);
25
26 static void save_user_format(struct rev_info *rev, const char *cp, int is_tformat)
27 {
28         free(user_format);
29         user_format = xstrdup(cp);
30         if (is_tformat)
31                 rev->use_terminator = 1;
32         rev->commit_format = CMIT_FMT_USERFORMAT;
33 }
34
35 static int git_pretty_formats_config(const char *var, const char *value, void *cb)
36 {
37         struct cmt_fmt_map *commit_format = NULL;
38         const char *name;
39         const char *fmt;
40         int i;
41
42         if (prefixcmp(var, "pretty."))
43                 return 0;
44
45         name = var + strlen("pretty.");
46         for (i = 0; i < builtin_formats_len; i++) {
47                 if (!strcmp(commit_formats[i].name, name))
48                         return 0;
49         }
50
51         for (i = builtin_formats_len; i < commit_formats_len; i++) {
52                 if (!strcmp(commit_formats[i].name, name)) {
53                         commit_format = &commit_formats[i];
54                         break;
55                 }
56         }
57
58         if (!commit_format) {
59                 ALLOC_GROW(commit_formats, commit_formats_len+1,
60                            commit_formats_alloc);
61                 commit_format = &commit_formats[commit_formats_len];
62                 memset(commit_format, 0, sizeof(*commit_format));
63                 commit_formats_len++;
64         }
65
66         commit_format->name = xstrdup(name);
67         commit_format->format = CMIT_FMT_USERFORMAT;
68         git_config_string(&fmt, var, value);
69         if (!prefixcmp(fmt, "format:") || !prefixcmp(fmt, "tformat:")) {
70                 commit_format->is_tformat = fmt[0] == 't';
71                 fmt = strchr(fmt, ':') + 1;
72         } else if (strchr(fmt, '%'))
73                 commit_format->is_tformat = 1;
74         else
75                 commit_format->is_alias = 1;
76         commit_format->user_format = fmt;
77
78         return 0;
79 }
80
81 static void setup_commit_formats(void)
82 {
83         struct cmt_fmt_map builtin_formats[] = {
84                 { "raw",        CMIT_FMT_RAW,           0 },
85                 { "medium",     CMIT_FMT_MEDIUM,        0 },
86                 { "short",      CMIT_FMT_SHORT,         0 },
87                 { "email",      CMIT_FMT_EMAIL,         0 },
88                 { "fuller",     CMIT_FMT_FULLER,        0 },
89                 { "full",       CMIT_FMT_FULL,          0 },
90                 { "oneline",    CMIT_FMT_ONELINE,       1 }
91         };
92         commit_formats_len = ARRAY_SIZE(builtin_formats);
93         builtin_formats_len = commit_formats_len;
94         ALLOC_GROW(commit_formats, commit_formats_len, commit_formats_alloc);
95         memcpy(commit_formats, builtin_formats,
96                sizeof(*builtin_formats)*ARRAY_SIZE(builtin_formats));
97
98         git_config(git_pretty_formats_config, NULL);
99 }
100
101 static struct cmt_fmt_map *find_commit_format_recursive(const char *sought,
102                                                         const char *original,
103                                                         int num_redirections)
104 {
105         struct cmt_fmt_map *found = NULL;
106         size_t found_match_len = 0;
107         int i;
108
109         if (num_redirections >= commit_formats_len)
110                 die("invalid --pretty format: "
111                     "'%s' references an alias which points to itself",
112                     original);
113
114         for (i = 0; i < commit_formats_len; i++) {
115                 size_t match_len;
116
117                 if (prefixcmp(commit_formats[i].name, sought))
118                         continue;
119
120                 match_len = strlen(commit_formats[i].name);
121                 if (found == NULL || found_match_len > match_len) {
122                         found = &commit_formats[i];
123                         found_match_len = match_len;
124                 }
125         }
126
127         if (found && found->is_alias) {
128                 found = find_commit_format_recursive(found->user_format,
129                                                      original,
130                                                      num_redirections+1);
131         }
132
133         return found;
134 }
135
136 static struct cmt_fmt_map *find_commit_format(const char *sought)
137 {
138         if (!commit_formats)
139                 setup_commit_formats();
140
141         return find_commit_format_recursive(sought, sought, 0);
142 }
143
144 void get_commit_format(const char *arg, struct rev_info *rev)
145 {
146         struct cmt_fmt_map *commit_format;
147
148         rev->use_terminator = 0;
149         if (!arg || !*arg) {
150                 rev->commit_format = CMIT_FMT_DEFAULT;
151                 return;
152         }
153         if (!prefixcmp(arg, "format:") || !prefixcmp(arg, "tformat:")) {
154                 save_user_format(rev, strchr(arg, ':') + 1, arg[0] == 't');
155                 return;
156         }
157
158         if (strchr(arg, '%')) {
159                 save_user_format(rev, arg, 1);
160                 return;
161         }
162
163         commit_format = find_commit_format(arg);
164         if (!commit_format)
165                 die("invalid --pretty format: %s", arg);
166
167         rev->commit_format = commit_format->format;
168         rev->use_terminator = commit_format->is_tformat;
169         if (commit_format->format == CMIT_FMT_USERFORMAT) {
170                 save_user_format(rev, commit_format->user_format,
171                                  commit_format->is_tformat);
172         }
173 }
174
175 /*
176  * Generic support for pretty-printing the header
177  */
178 static int get_one_line(const char *msg)
179 {
180         int ret = 0;
181
182         for (;;) {
183                 char c = *msg++;
184                 if (!c)
185                         break;
186                 ret++;
187                 if (c == '\n')
188                         break;
189         }
190         return ret;
191 }
192
193 /* High bit set, or ISO-2022-INT */
194 static int non_ascii(int ch)
195 {
196         return !isascii(ch) || ch == '\033';
197 }
198
199 int has_non_ascii(const char *s)
200 {
201         int ch;
202         if (!s)
203                 return 0;
204         while ((ch = *s++) != '\0') {
205                 if (non_ascii(ch))
206                         return 1;
207         }
208         return 0;
209 }
210
211 static int is_rfc2047_special(char ch)
212 {
213         return (non_ascii(ch) || (ch == '=') || (ch == '?') || (ch == '_'));
214 }
215
216 static void add_rfc2047(struct strbuf *sb, const char *line, int len,
217                        const char *encoding)
218 {
219         static const int max_length = 78; /* per rfc2822 */
220         int i;
221         int line_len;
222
223         /* How many bytes are already used on the current line? */
224         for (i = sb->len - 1; i >= 0; i--)
225                 if (sb->buf[i] == '\n')
226                         break;
227         line_len = sb->len - (i+1);
228
229         for (i = 0; i < len; i++) {
230                 int ch = line[i];
231                 if (non_ascii(ch) || ch == '\n')
232                         goto needquote;
233                 if ((i + 1 < len) && (ch == '=' && line[i+1] == '?'))
234                         goto needquote;
235         }
236         strbuf_add_wrapped_bytes(sb, line, len, 0, 1, max_length - line_len);
237         return;
238
239 needquote:
240         strbuf_grow(sb, len * 3 + strlen(encoding) + 100);
241         strbuf_addf(sb, "=?%s?q?", encoding);
242         line_len += strlen(encoding) + 5; /* 5 for =??q? */
243         for (i = 0; i < len; i++) {
244                 unsigned ch = line[i] & 0xFF;
245
246                 if (line_len >= max_length - 2) {
247                         strbuf_addf(sb, "?=\n =?%s?q?", encoding);
248                         line_len = strlen(encoding) + 5 + 1; /* =??q? plus SP */
249                 }
250
251                 /*
252                  * We encode ' ' using '=20' even though rfc2047
253                  * allows using '_' for readability.  Unfortunately,
254                  * many programs do not understand this and just
255                  * leave the underscore in place.
256                  */
257                 if (is_rfc2047_special(ch) || ch == ' ' || ch == '\n') {
258                         strbuf_addf(sb, "=%02X", ch);
259                         line_len += 3;
260                 }
261                 else {
262                         strbuf_addch(sb, ch);
263                         line_len++;
264                 }
265         }
266         strbuf_addstr(sb, "?=");
267 }
268
269 void pp_user_info(const char *what, enum cmit_fmt fmt, struct strbuf *sb,
270                   const char *line, enum date_mode dmode,
271                   const char *encoding)
272 {
273         char *date;
274         int namelen;
275         unsigned long time;
276         int tz;
277
278         if (fmt == CMIT_FMT_ONELINE)
279                 return;
280         date = strchr(line, '>');
281         if (!date)
282                 return;
283         namelen = ++date - line;
284         time = strtoul(date, &date, 10);
285         tz = strtol(date, NULL, 10);
286
287         if (fmt == CMIT_FMT_EMAIL) {
288                 char *name_tail = strchr(line, '<');
289                 int display_name_length;
290                 int final_line;
291                 if (!name_tail)
292                         return;
293                 while (line < name_tail && isspace(name_tail[-1]))
294                         name_tail--;
295                 display_name_length = name_tail - line;
296                 strbuf_addstr(sb, "From: ");
297                 add_rfc2047(sb, line, display_name_length, encoding);
298                 for (final_line = 0; final_line < sb->len; final_line++)
299                         if (sb->buf[sb->len - final_line - 1] == '\n')
300                                 break;
301                 if (namelen - display_name_length + final_line > 78) {
302                         strbuf_addch(sb, '\n');
303                         if (!isspace(name_tail[0]))
304                                 strbuf_addch(sb, ' ');
305                 }
306                 strbuf_add(sb, name_tail, namelen - display_name_length);
307                 strbuf_addch(sb, '\n');
308         } else {
309                 strbuf_addf(sb, "%s: %.*s%.*s\n", what,
310                               (fmt == CMIT_FMT_FULLER) ? 4 : 0,
311                               "    ", namelen, line);
312         }
313         switch (fmt) {
314         case CMIT_FMT_MEDIUM:
315                 strbuf_addf(sb, "Date:   %s\n", show_date(time, tz, dmode));
316                 break;
317         case CMIT_FMT_EMAIL:
318                 strbuf_addf(sb, "Date: %s\n", show_date(time, tz, DATE_RFC2822));
319                 break;
320         case CMIT_FMT_FULLER:
321                 strbuf_addf(sb, "%sDate: %s\n", what, show_date(time, tz, dmode));
322                 break;
323         default:
324                 /* notin' */
325                 break;
326         }
327 }
328
329 static int is_empty_line(const char *line, int *len_p)
330 {
331         int len = *len_p;
332         while (len && isspace(line[len-1]))
333                 len--;
334         *len_p = len;
335         return !len;
336 }
337
338 static const char *skip_empty_lines(const char *msg)
339 {
340         for (;;) {
341                 int linelen = get_one_line(msg);
342                 int ll = linelen;
343                 if (!linelen)
344                         break;
345                 if (!is_empty_line(msg, &ll))
346                         break;
347                 msg += linelen;
348         }
349         return msg;
350 }
351
352 static void add_merge_info(enum cmit_fmt fmt, struct strbuf *sb,
353                         const struct commit *commit, int abbrev)
354 {
355         struct commit_list *parent = commit->parents;
356
357         if ((fmt == CMIT_FMT_ONELINE) || (fmt == CMIT_FMT_EMAIL) ||
358             !parent || !parent->next)
359                 return;
360
361         strbuf_addstr(sb, "Merge:");
362
363         while (parent) {
364                 struct commit *p = parent->item;
365                 const char *hex = NULL;
366                 if (abbrev)
367                         hex = find_unique_abbrev(p->object.sha1, abbrev);
368                 if (!hex)
369                         hex = sha1_to_hex(p->object.sha1);
370                 parent = parent->next;
371
372                 strbuf_addf(sb, " %s", hex);
373         }
374         strbuf_addch(sb, '\n');
375 }
376
377 static char *get_header(const struct commit *commit, const char *key)
378 {
379         int key_len = strlen(key);
380         const char *line = commit->buffer;
381
382         for (;;) {
383                 const char *eol = strchr(line, '\n'), *next;
384
385                 if (line == eol)
386                         return NULL;
387                 if (!eol) {
388                         eol = line + strlen(line);
389                         next = NULL;
390                 } else
391                         next = eol + 1;
392                 if (eol - line > key_len &&
393                     !strncmp(line, key, key_len) &&
394                     line[key_len] == ' ') {
395                         return xmemdupz(line + key_len + 1, eol - line - key_len - 1);
396                 }
397                 line = next;
398         }
399 }
400
401 static char *replace_encoding_header(char *buf, const char *encoding)
402 {
403         struct strbuf tmp = STRBUF_INIT;
404         size_t start, len;
405         char *cp = buf;
406
407         /* guess if there is an encoding header before a \n\n */
408         while (strncmp(cp, "encoding ", strlen("encoding "))) {
409                 cp = strchr(cp, '\n');
410                 if (!cp || *++cp == '\n')
411                         return buf;
412         }
413         start = cp - buf;
414         cp = strchr(cp, '\n');
415         if (!cp)
416                 return buf; /* should not happen but be defensive */
417         len = cp + 1 - (buf + start);
418
419         strbuf_attach(&tmp, buf, strlen(buf), strlen(buf) + 1);
420         if (is_encoding_utf8(encoding)) {
421                 /* we have re-coded to UTF-8; drop the header */
422                 strbuf_remove(&tmp, start, len);
423         } else {
424                 /* just replaces XXXX in 'encoding XXXX\n' */
425                 strbuf_splice(&tmp, start + strlen("encoding "),
426                                           len - strlen("encoding \n"),
427                                           encoding, strlen(encoding));
428         }
429         return strbuf_detach(&tmp, NULL);
430 }
431
432 char *logmsg_reencode(const struct commit *commit,
433                       const char *output_encoding)
434 {
435         static const char *utf8 = "UTF-8";
436         const char *use_encoding;
437         char *encoding;
438         char *out;
439
440         if (!*output_encoding)
441                 return NULL;
442         encoding = get_header(commit, "encoding");
443         use_encoding = encoding ? encoding : utf8;
444         if (!strcmp(use_encoding, output_encoding))
445                 if (encoding) /* we'll strip encoding header later */
446                         out = xstrdup(commit->buffer);
447                 else
448                         return NULL; /* nothing to do */
449         else
450                 out = reencode_string(commit->buffer,
451                                       output_encoding, use_encoding);
452         if (out)
453                 out = replace_encoding_header(out, output_encoding);
454
455         free(encoding);
456         return out;
457 }
458
459 static int mailmap_name(char *email, int email_len, char *name, int name_len)
460 {
461         static struct string_list *mail_map;
462         if (!mail_map) {
463                 mail_map = xcalloc(1, sizeof(*mail_map));
464                 read_mailmap(mail_map, NULL);
465         }
466         return mail_map->nr && map_user(mail_map, email, email_len, name, name_len);
467 }
468
469 static size_t format_person_part(struct strbuf *sb, char part,
470                                  const char *msg, int len, enum date_mode dmode)
471 {
472         /* currently all placeholders have same length */
473         const int placeholder_len = 2;
474         int start, end, tz = 0;
475         unsigned long date = 0;
476         char *ep;
477         const char *name_start, *name_end, *mail_start, *mail_end, *msg_end = msg+len;
478         char person_name[1024];
479         char person_mail[1024];
480
481         /* advance 'end' to point to email start delimiter */
482         for (end = 0; end < len && msg[end] != '<'; end++)
483                 ; /* do nothing */
484
485         /*
486          * When end points at the '<' that we found, it should have
487          * matching '>' later, which means 'end' must be strictly
488          * below len - 1.
489          */
490         if (end >= len - 2)
491                 goto skip;
492
493         /* Seek for both name and email part */
494         name_start = msg;
495         name_end = msg+end;
496         while (name_end > name_start && isspace(*(name_end-1)))
497                 name_end--;
498         mail_start = msg+end+1;
499         mail_end = mail_start;
500         while (mail_end < msg_end && *mail_end != '>')
501                 mail_end++;
502         if (mail_end == msg_end)
503                 goto skip;
504         end = mail_end-msg;
505
506         if (part == 'N' || part == 'E') { /* mailmap lookup */
507                 strlcpy(person_name, name_start, name_end-name_start+1);
508                 strlcpy(person_mail, mail_start, mail_end-mail_start+1);
509                 mailmap_name(person_mail, sizeof(person_mail), person_name, sizeof(person_name));
510                 name_start = person_name;
511                 name_end = name_start + strlen(person_name);
512                 mail_start = person_mail;
513                 mail_end = mail_start +  strlen(person_mail);
514         }
515         if (part == 'n' || part == 'N') {       /* name */
516                 strbuf_add(sb, name_start, name_end-name_start);
517                 return placeholder_len;
518         }
519         if (part == 'e' || part == 'E') {       /* email */
520                 strbuf_add(sb, mail_start, mail_end-mail_start);
521                 return placeholder_len;
522         }
523
524         /* advance 'start' to point to date start delimiter */
525         for (start = end + 1; start < len && isspace(msg[start]); start++)
526                 ; /* do nothing */
527         if (start >= len)
528                 goto skip;
529         date = strtoul(msg + start, &ep, 10);
530         if (msg + start == ep)
531                 goto skip;
532
533         if (part == 't') {      /* date, UNIX timestamp */
534                 strbuf_add(sb, msg + start, ep - (msg + start));
535                 return placeholder_len;
536         }
537
538         /* parse tz */
539         for (start = ep - msg + 1; start < len && isspace(msg[start]); start++)
540                 ; /* do nothing */
541         if (start + 1 < len) {
542                 tz = strtoul(msg + start + 1, NULL, 10);
543                 if (msg[start] == '-')
544                         tz = -tz;
545         }
546
547         switch (part) {
548         case 'd':       /* date */
549                 strbuf_addstr(sb, show_date(date, tz, dmode));
550                 return placeholder_len;
551         case 'D':       /* date, RFC2822 style */
552                 strbuf_addstr(sb, show_date(date, tz, DATE_RFC2822));
553                 return placeholder_len;
554         case 'r':       /* date, relative */
555                 strbuf_addstr(sb, show_date(date, tz, DATE_RELATIVE));
556                 return placeholder_len;
557         case 'i':       /* date, ISO 8601 */
558                 strbuf_addstr(sb, show_date(date, tz, DATE_ISO8601));
559                 return placeholder_len;
560         }
561
562 skip:
563         /*
564          * bogus commit, 'sb' cannot be updated, but we still need to
565          * compute a valid return value.
566          */
567         if (part == 'n' || part == 'e' || part == 't' || part == 'd'
568             || part == 'D' || part == 'r' || part == 'i')
569                 return placeholder_len;
570
571         return 0; /* unknown placeholder */
572 }
573
574 struct chunk {
575         size_t off;
576         size_t len;
577 };
578
579 struct format_commit_context {
580         const struct commit *commit;
581         const struct pretty_print_context *pretty_ctx;
582         unsigned commit_header_parsed:1;
583         unsigned commit_message_parsed:1;
584         char *message;
585         size_t width, indent1, indent2;
586
587         /* These offsets are relative to the start of the commit message. */
588         struct chunk author;
589         struct chunk committer;
590         struct chunk encoding;
591         size_t message_off;
592         size_t subject_off;
593         size_t body_off;
594
595         /* The following ones are relative to the result struct strbuf. */
596         struct chunk abbrev_commit_hash;
597         struct chunk abbrev_tree_hash;
598         struct chunk abbrev_parent_hashes;
599         size_t wrap_start;
600 };
601
602 static int add_again(struct strbuf *sb, struct chunk *chunk)
603 {
604         if (chunk->len) {
605                 strbuf_adddup(sb, chunk->off, chunk->len);
606                 return 1;
607         }
608
609         /*
610          * We haven't seen this chunk before.  Our caller is surely
611          * going to add it the hard way now.  Remember the most likely
612          * start of the to-be-added chunk: the current end of the
613          * struct strbuf.
614          */
615         chunk->off = sb->len;
616         return 0;
617 }
618
619 static void parse_commit_header(struct format_commit_context *context)
620 {
621         const char *msg = context->message;
622         int i;
623
624         for (i = 0; msg[i]; i++) {
625                 int eol;
626                 for (eol = i; msg[eol] && msg[eol] != '\n'; eol++)
627                         ; /* do nothing */
628
629                 if (i == eol) {
630                         break;
631                 } else if (!prefixcmp(msg + i, "author ")) {
632                         context->author.off = i + 7;
633                         context->author.len = eol - i - 7;
634                 } else if (!prefixcmp(msg + i, "committer ")) {
635                         context->committer.off = i + 10;
636                         context->committer.len = eol - i - 10;
637                 } else if (!prefixcmp(msg + i, "encoding ")) {
638                         context->encoding.off = i + 9;
639                         context->encoding.len = eol - i - 9;
640                 }
641                 i = eol;
642         }
643         context->message_off = i;
644         context->commit_header_parsed = 1;
645 }
646
647 static int istitlechar(char c)
648 {
649         return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
650                 (c >= '0' && c <= '9') || c == '.' || c == '_';
651 }
652
653 static void format_sanitized_subject(struct strbuf *sb, const char *msg)
654 {
655         size_t trimlen;
656         size_t start_len = sb->len;
657         int space = 2;
658
659         for (; *msg && *msg != '\n'; msg++) {
660                 if (istitlechar(*msg)) {
661                         if (space == 1)
662                                 strbuf_addch(sb, '-');
663                         space = 0;
664                         strbuf_addch(sb, *msg);
665                         if (*msg == '.')
666                                 while (*(msg+1) == '.')
667                                         msg++;
668                 } else
669                         space |= 1;
670         }
671
672         /* trim any trailing '.' or '-' characters */
673         trimlen = 0;
674         while (sb->len - trimlen > start_len &&
675                 (sb->buf[sb->len - 1 - trimlen] == '.'
676                 || sb->buf[sb->len - 1 - trimlen] == '-'))
677                 trimlen++;
678         strbuf_remove(sb, sb->len - trimlen, trimlen);
679 }
680
681 const char *format_subject(struct strbuf *sb, const char *msg,
682                            const char *line_separator)
683 {
684         int first = 1;
685
686         for (;;) {
687                 const char *line = msg;
688                 int linelen = get_one_line(line);
689
690                 msg += linelen;
691                 if (!linelen || is_empty_line(line, &linelen))
692                         break;
693
694                 if (!sb)
695                         continue;
696                 strbuf_grow(sb, linelen + 2);
697                 if (!first)
698                         strbuf_addstr(sb, line_separator);
699                 strbuf_add(sb, line, linelen);
700                 first = 0;
701         }
702         return msg;
703 }
704
705 static void parse_commit_message(struct format_commit_context *c)
706 {
707         const char *msg = c->message + c->message_off;
708         const char *start = c->message;
709
710         msg = skip_empty_lines(msg);
711         c->subject_off = msg - start;
712
713         msg = format_subject(NULL, msg, NULL);
714         msg = skip_empty_lines(msg);
715         c->body_off = msg - start;
716
717         c->commit_message_parsed = 1;
718 }
719
720 static void format_decoration(struct strbuf *sb, const struct commit *commit)
721 {
722         struct name_decoration *d;
723         const char *prefix = " (";
724
725         load_ref_decorations(DECORATE_SHORT_REFS);
726         d = lookup_decoration(&name_decoration, &commit->object);
727         while (d) {
728                 strbuf_addstr(sb, prefix);
729                 prefix = ", ";
730                 strbuf_addstr(sb, d->name);
731                 d = d->next;
732         }
733         if (prefix[0] == ',')
734                 strbuf_addch(sb, ')');
735 }
736
737 static void strbuf_wrap(struct strbuf *sb, size_t pos,
738                         size_t width, size_t indent1, size_t indent2)
739 {
740         struct strbuf tmp = STRBUF_INIT;
741
742         if (pos)
743                 strbuf_add(&tmp, sb->buf, pos);
744         strbuf_add_wrapped_text(&tmp, sb->buf + pos,
745                                 (int) indent1, (int) indent2, (int) width);
746         strbuf_swap(&tmp, sb);
747         strbuf_release(&tmp);
748 }
749
750 static void rewrap_message_tail(struct strbuf *sb,
751                                 struct format_commit_context *c,
752                                 size_t new_width, size_t new_indent1,
753                                 size_t new_indent2)
754 {
755         if (c->width == new_width && c->indent1 == new_indent1 &&
756             c->indent2 == new_indent2)
757                 return;
758         if (c->wrap_start < sb->len)
759                 strbuf_wrap(sb, c->wrap_start, c->width, c->indent1, c->indent2);
760         c->wrap_start = sb->len;
761         c->width = new_width;
762         c->indent1 = new_indent1;
763         c->indent2 = new_indent2;
764 }
765
766 static size_t format_commit_one(struct strbuf *sb, const char *placeholder,
767                                 void *context)
768 {
769         struct format_commit_context *c = context;
770         const struct commit *commit = c->commit;
771         const char *msg = c->message;
772         struct commit_list *p;
773         int h1, h2;
774
775         /* these are independent of the commit */
776         switch (placeholder[0]) {
777         case 'C':
778                 if (placeholder[1] == '(') {
779                         const char *end = strchr(placeholder + 2, ')');
780                         char color[COLOR_MAXLEN];
781                         if (!end)
782                                 return 0;
783                         color_parse_mem(placeholder + 2,
784                                         end - (placeholder + 2),
785                                         "--pretty format", color);
786                         strbuf_addstr(sb, color);
787                         return end - placeholder + 1;
788                 }
789                 if (!prefixcmp(placeholder + 1, "red")) {
790                         strbuf_addstr(sb, GIT_COLOR_RED);
791                         return 4;
792                 } else if (!prefixcmp(placeholder + 1, "green")) {
793                         strbuf_addstr(sb, GIT_COLOR_GREEN);
794                         return 6;
795                 } else if (!prefixcmp(placeholder + 1, "blue")) {
796                         strbuf_addstr(sb, GIT_COLOR_BLUE);
797                         return 5;
798                 } else if (!prefixcmp(placeholder + 1, "reset")) {
799                         strbuf_addstr(sb, GIT_COLOR_RESET);
800                         return 6;
801                 } else
802                         return 0;
803         case 'n':               /* newline */
804                 strbuf_addch(sb, '\n');
805                 return 1;
806         case 'x':
807                 /* %x00 == NUL, %x0a == LF, etc. */
808                 if (0 <= (h1 = hexval_table[0xff & placeholder[1]]) &&
809                     h1 <= 16 &&
810                     0 <= (h2 = hexval_table[0xff & placeholder[2]]) &&
811                     h2 <= 16) {
812                         strbuf_addch(sb, (h1<<4)|h2);
813                         return 3;
814                 } else
815                         return 0;
816         case 'w':
817                 if (placeholder[1] == '(') {
818                         unsigned long width = 0, indent1 = 0, indent2 = 0;
819                         char *next;
820                         const char *start = placeholder + 2;
821                         const char *end = strchr(start, ')');
822                         if (!end)
823                                 return 0;
824                         if (end > start) {
825                                 width = strtoul(start, &next, 10);
826                                 if (*next == ',') {
827                                         indent1 = strtoul(next + 1, &next, 10);
828                                         if (*next == ',') {
829                                                 indent2 = strtoul(next + 1,
830                                                                  &next, 10);
831                                         }
832                                 }
833                                 if (*next != ')')
834                                         return 0;
835                         }
836                         rewrap_message_tail(sb, c, width, indent1, indent2);
837                         return end - placeholder + 1;
838                 } else
839                         return 0;
840         }
841
842         /* these depend on the commit */
843         if (!commit->object.parsed)
844                 parse_object(commit->object.sha1);
845
846         switch (placeholder[0]) {
847         case 'H':               /* commit hash */
848                 strbuf_addstr(sb, sha1_to_hex(commit->object.sha1));
849                 return 1;
850         case 'h':               /* abbreviated commit hash */
851                 if (add_again(sb, &c->abbrev_commit_hash))
852                         return 1;
853                 strbuf_addstr(sb, find_unique_abbrev(commit->object.sha1,
854                                                      c->pretty_ctx->abbrev));
855                 c->abbrev_commit_hash.len = sb->len - c->abbrev_commit_hash.off;
856                 return 1;
857         case 'T':               /* tree hash */
858                 strbuf_addstr(sb, sha1_to_hex(commit->tree->object.sha1));
859                 return 1;
860         case 't':               /* abbreviated tree hash */
861                 if (add_again(sb, &c->abbrev_tree_hash))
862                         return 1;
863                 strbuf_addstr(sb, find_unique_abbrev(commit->tree->object.sha1,
864                                                      c->pretty_ctx->abbrev));
865                 c->abbrev_tree_hash.len = sb->len - c->abbrev_tree_hash.off;
866                 return 1;
867         case 'P':               /* parent hashes */
868                 for (p = commit->parents; p; p = p->next) {
869                         if (p != commit->parents)
870                                 strbuf_addch(sb, ' ');
871                         strbuf_addstr(sb, sha1_to_hex(p->item->object.sha1));
872                 }
873                 return 1;
874         case 'p':               /* abbreviated parent hashes */
875                 if (add_again(sb, &c->abbrev_parent_hashes))
876                         return 1;
877                 for (p = commit->parents; p; p = p->next) {
878                         if (p != commit->parents)
879                                 strbuf_addch(sb, ' ');
880                         strbuf_addstr(sb, find_unique_abbrev(
881                                         p->item->object.sha1,
882                                         c->pretty_ctx->abbrev));
883                 }
884                 c->abbrev_parent_hashes.len = sb->len -
885                                               c->abbrev_parent_hashes.off;
886                 return 1;
887         case 'm':               /* left/right/bottom */
888                 strbuf_addstr(sb, get_revision_mark(NULL, commit));
889                 return 1;
890         case 'd':
891                 format_decoration(sb, commit);
892                 return 1;
893         case 'g':               /* reflog info */
894                 switch(placeholder[1]) {
895                 case 'd':       /* reflog selector */
896                 case 'D':
897                         if (c->pretty_ctx->reflog_info)
898                                 get_reflog_selector(sb,
899                                                     c->pretty_ctx->reflog_info,
900                                                     c->pretty_ctx->date_mode,
901                                                     (placeholder[1] == 'd'));
902                         return 2;
903                 case 's':       /* reflog message */
904                         if (c->pretty_ctx->reflog_info)
905                                 get_reflog_message(sb, c->pretty_ctx->reflog_info);
906                         return 2;
907                 }
908                 return 0;       /* unknown %g placeholder */
909         case 'N':
910                 if (c->pretty_ctx->show_notes) {
911                         format_display_notes(commit->object.sha1, sb,
912                                     get_log_output_encoding(), 0);
913                         return 1;
914                 }
915                 return 0;
916         }
917
918         /* For the rest we have to parse the commit header. */
919         if (!c->commit_header_parsed)
920                 parse_commit_header(c);
921
922         switch (placeholder[0]) {
923         case 'a':       /* author ... */
924                 return format_person_part(sb, placeholder[1],
925                                    msg + c->author.off, c->author.len,
926                                    c->pretty_ctx->date_mode);
927         case 'c':       /* committer ... */
928                 return format_person_part(sb, placeholder[1],
929                                    msg + c->committer.off, c->committer.len,
930                                    c->pretty_ctx->date_mode);
931         case 'e':       /* encoding */
932                 strbuf_add(sb, msg + c->encoding.off, c->encoding.len);
933                 return 1;
934         case 'B':       /* raw body */
935                 /* message_off is always left at the initial newline */
936                 strbuf_addstr(sb, msg + c->message_off + 1);
937                 return 1;
938         }
939
940         /* Now we need to parse the commit message. */
941         if (!c->commit_message_parsed)
942                 parse_commit_message(c);
943
944         switch (placeholder[0]) {
945         case 's':       /* subject */
946                 format_subject(sb, msg + c->subject_off, " ");
947                 return 1;
948         case 'f':       /* sanitized subject */
949                 format_sanitized_subject(sb, msg + c->subject_off);
950                 return 1;
951         case 'b':       /* body */
952                 strbuf_addstr(sb, msg + c->body_off);
953                 return 1;
954         }
955         return 0;       /* unknown placeholder */
956 }
957
958 static size_t format_commit_item(struct strbuf *sb, const char *placeholder,
959                                  void *context)
960 {
961         int consumed;
962         size_t orig_len;
963         enum {
964                 NO_MAGIC,
965                 ADD_LF_BEFORE_NON_EMPTY,
966                 DEL_LF_BEFORE_EMPTY,
967                 ADD_SP_BEFORE_NON_EMPTY
968         } magic = NO_MAGIC;
969
970         switch (placeholder[0]) {
971         case '-':
972                 magic = DEL_LF_BEFORE_EMPTY;
973                 break;
974         case '+':
975                 magic = ADD_LF_BEFORE_NON_EMPTY;
976                 break;
977         case ' ':
978                 magic = ADD_SP_BEFORE_NON_EMPTY;
979                 break;
980         default:
981                 break;
982         }
983         if (magic != NO_MAGIC)
984                 placeholder++;
985
986         orig_len = sb->len;
987         consumed = format_commit_one(sb, placeholder, context);
988         if (magic == NO_MAGIC)
989                 return consumed;
990
991         if ((orig_len == sb->len) && magic == DEL_LF_BEFORE_EMPTY) {
992                 while (sb->len && sb->buf[sb->len - 1] == '\n')
993                         strbuf_setlen(sb, sb->len - 1);
994         } else if (orig_len != sb->len) {
995                 if (magic == ADD_LF_BEFORE_NON_EMPTY)
996                         strbuf_insert(sb, orig_len, "\n", 1);
997                 else if (magic == ADD_SP_BEFORE_NON_EMPTY)
998                         strbuf_insert(sb, orig_len, " ", 1);
999         }
1000         return consumed + 1;
1001 }
1002
1003 static size_t userformat_want_item(struct strbuf *sb, const char *placeholder,
1004                                    void *context)
1005 {
1006         struct userformat_want *w = context;
1007
1008         if (*placeholder == '+' || *placeholder == '-' || *placeholder == ' ')
1009                 placeholder++;
1010
1011         switch (*placeholder) {
1012         case 'N':
1013                 w->notes = 1;
1014                 break;
1015         }
1016         return 0;
1017 }
1018
1019 void userformat_find_requirements(const char *fmt, struct userformat_want *w)
1020 {
1021         struct strbuf dummy = STRBUF_INIT;
1022
1023         if (!fmt) {
1024                 if (!user_format)
1025                         return;
1026                 fmt = user_format;
1027         }
1028         strbuf_expand(&dummy, user_format, userformat_want_item, w);
1029         strbuf_release(&dummy);
1030 }
1031
1032 void format_commit_message(const struct commit *commit,
1033                            const char *format, struct strbuf *sb,
1034                            const struct pretty_print_context *pretty_ctx)
1035 {
1036         struct format_commit_context context;
1037         static const char utf8[] = "UTF-8";
1038         const char *enc;
1039         const char *output_enc = pretty_ctx->output_encoding;
1040
1041         memset(&context, 0, sizeof(context));
1042         context.commit = commit;
1043         context.pretty_ctx = pretty_ctx;
1044         context.wrap_start = sb->len;
1045         context.message = commit->buffer;
1046         if (output_enc) {
1047                 enc = get_header(commit, "encoding");
1048                 enc = enc ? enc : utf8;
1049                 if (strcmp(enc, output_enc))
1050                         context.message = logmsg_reencode(commit, output_enc);
1051         }
1052
1053         strbuf_expand(sb, format, format_commit_item, &context);
1054         rewrap_message_tail(sb, &context, 0, 0, 0);
1055
1056         if (context.message != commit->buffer)
1057                 free(context.message);
1058 }
1059
1060 static void pp_header(enum cmit_fmt fmt,
1061                       int abbrev,
1062                       enum date_mode dmode,
1063                       const char *encoding,
1064                       const struct commit *commit,
1065                       const char **msg_p,
1066                       struct strbuf *sb)
1067 {
1068         int parents_shown = 0;
1069
1070         for (;;) {
1071                 const char *line = *msg_p;
1072                 int linelen = get_one_line(*msg_p);
1073
1074                 if (!linelen)
1075                         return;
1076                 *msg_p += linelen;
1077
1078                 if (linelen == 1)
1079                         /* End of header */
1080                         return;
1081
1082                 if (fmt == CMIT_FMT_RAW) {
1083                         strbuf_add(sb, line, linelen);
1084                         continue;
1085                 }
1086
1087                 if (!memcmp(line, "parent ", 7)) {
1088                         if (linelen != 48)
1089                                 die("bad parent line in commit");
1090                         continue;
1091                 }
1092
1093                 if (!parents_shown) {
1094                         struct commit_list *parent;
1095                         int num;
1096                         for (parent = commit->parents, num = 0;
1097                              parent;
1098                              parent = parent->next, num++)
1099                                 ;
1100                         /* with enough slop */
1101                         strbuf_grow(sb, num * 50 + 20);
1102                         add_merge_info(fmt, sb, commit, abbrev);
1103                         parents_shown = 1;
1104                 }
1105
1106                 /*
1107                  * MEDIUM == DEFAULT shows only author with dates.
1108                  * FULL shows both authors but not dates.
1109                  * FULLER shows both authors and dates.
1110                  */
1111                 if (!memcmp(line, "author ", 7)) {
1112                         strbuf_grow(sb, linelen + 80);
1113                         pp_user_info("Author", fmt, sb, line + 7, dmode, encoding);
1114                 }
1115                 if (!memcmp(line, "committer ", 10) &&
1116                     (fmt == CMIT_FMT_FULL || fmt == CMIT_FMT_FULLER)) {
1117                         strbuf_grow(sb, linelen + 80);
1118                         pp_user_info("Commit", fmt, sb, line + 10, dmode, encoding);
1119                 }
1120         }
1121 }
1122
1123 void pp_title_line(enum cmit_fmt fmt,
1124                    const char **msg_p,
1125                    struct strbuf *sb,
1126                    const char *subject,
1127                    const char *after_subject,
1128                    const char *encoding,
1129                    int need_8bit_cte)
1130 {
1131         struct strbuf title;
1132
1133         strbuf_init(&title, 80);
1134         *msg_p = format_subject(&title, *msg_p, " ");
1135
1136         strbuf_grow(sb, title.len + 1024);
1137         if (subject) {
1138                 strbuf_addstr(sb, subject);
1139                 add_rfc2047(sb, title.buf, title.len, encoding);
1140         } else {
1141                 strbuf_addbuf(sb, &title);
1142         }
1143         strbuf_addch(sb, '\n');
1144
1145         if (need_8bit_cte > 0) {
1146                 const char *header_fmt =
1147                         "MIME-Version: 1.0\n"
1148                         "Content-Type: text/plain; charset=%s\n"
1149                         "Content-Transfer-Encoding: 8bit\n";
1150                 strbuf_addf(sb, header_fmt, encoding);
1151         }
1152         if (after_subject) {
1153                 strbuf_addstr(sb, after_subject);
1154         }
1155         if (fmt == CMIT_FMT_EMAIL) {
1156                 strbuf_addch(sb, '\n');
1157         }
1158         strbuf_release(&title);
1159 }
1160
1161 void pp_remainder(enum cmit_fmt fmt,
1162                   const char **msg_p,
1163                   struct strbuf *sb,
1164                   int indent)
1165 {
1166         int first = 1;
1167         for (;;) {
1168                 const char *line = *msg_p;
1169                 int linelen = get_one_line(line);
1170                 *msg_p += linelen;
1171
1172                 if (!linelen)
1173                         break;
1174
1175                 if (is_empty_line(line, &linelen)) {
1176                         if (first)
1177                                 continue;
1178                         if (fmt == CMIT_FMT_SHORT)
1179                                 break;
1180                 }
1181                 first = 0;
1182
1183                 strbuf_grow(sb, linelen + indent + 20);
1184                 if (indent) {
1185                         memset(sb->buf + sb->len, ' ', indent);
1186                         strbuf_setlen(sb, sb->len + indent);
1187                 }
1188                 strbuf_add(sb, line, linelen);
1189                 strbuf_addch(sb, '\n');
1190         }
1191 }
1192
1193 char *reencode_commit_message(const struct commit *commit, const char **encoding_p)
1194 {
1195         const char *encoding;
1196
1197         encoding = get_log_output_encoding();
1198         if (encoding_p)
1199                 *encoding_p = encoding;
1200         return logmsg_reencode(commit, encoding);
1201 }
1202
1203 void pretty_print_commit(enum cmit_fmt fmt, const struct commit *commit,
1204                          struct strbuf *sb,
1205                          const struct pretty_print_context *context)
1206 {
1207         unsigned long beginning_of_body;
1208         int indent = 4;
1209         const char *msg = commit->buffer;
1210         char *reencoded;
1211         const char *encoding;
1212         int need_8bit_cte = context->need_8bit_cte;
1213
1214         if (fmt == CMIT_FMT_USERFORMAT) {
1215                 format_commit_message(commit, user_format, sb, context);
1216                 return;
1217         }
1218
1219         reencoded = reencode_commit_message(commit, &encoding);
1220         if (reencoded) {
1221                 msg = reencoded;
1222         }
1223
1224         if (fmt == CMIT_FMT_ONELINE || fmt == CMIT_FMT_EMAIL)
1225                 indent = 0;
1226
1227         /*
1228          * We need to check and emit Content-type: to mark it
1229          * as 8-bit if we haven't done so.
1230          */
1231         if (fmt == CMIT_FMT_EMAIL && need_8bit_cte == 0) {
1232                 int i, ch, in_body;
1233
1234                 for (in_body = i = 0; (ch = msg[i]); i++) {
1235                         if (!in_body) {
1236                                 /* author could be non 7-bit ASCII but
1237                                  * the log may be so; skip over the
1238                                  * header part first.
1239                                  */
1240                                 if (ch == '\n' && msg[i+1] == '\n')
1241                                         in_body = 1;
1242                         }
1243                         else if (non_ascii(ch)) {
1244                                 need_8bit_cte = 1;
1245                                 break;
1246                         }
1247                 }
1248         }
1249
1250         pp_header(fmt, context->abbrev, context->date_mode, encoding,
1251                   commit, &msg, sb);
1252         if (fmt != CMIT_FMT_ONELINE && !context->subject) {
1253                 strbuf_addch(sb, '\n');
1254         }
1255
1256         /* Skip excess blank lines at the beginning of body, if any... */
1257         msg = skip_empty_lines(msg);
1258
1259         /* These formats treat the title line specially. */
1260         if (fmt == CMIT_FMT_ONELINE || fmt == CMIT_FMT_EMAIL)
1261                 pp_title_line(fmt, &msg, sb, context->subject,
1262                               context->after_subject, encoding, need_8bit_cte);
1263
1264         beginning_of_body = sb->len;
1265         if (fmt != CMIT_FMT_ONELINE)
1266                 pp_remainder(fmt, &msg, sb, indent);
1267         strbuf_rtrim(sb);
1268
1269         /* Make sure there is an EOLN for the non-oneline case */
1270         if (fmt != CMIT_FMT_ONELINE)
1271                 strbuf_addch(sb, '\n');
1272
1273         /*
1274          * The caller may append additional body text in e-mail
1275          * format.  Make sure we did not strip the blank line
1276          * between the header and the body.
1277          */
1278         if (fmt == CMIT_FMT_EMAIL && sb->len <= beginning_of_body)
1279                 strbuf_addch(sb, '\n');
1280
1281         if (context->show_notes)
1282                 format_display_notes(commit->object.sha1, sb, encoding,
1283                                      NOTES_SHOW_HEADER | NOTES_INDENT);
1284
1285         free(reencoded);
1286 }