git.oblomov.eu Git - git/blob - 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 #include "gpg-interface.h"
  13
  14 static char *user_format;
  15 static struct cmt_fmt_map {
  16         const char *name;
  17         enum cmit_fmt format;
  18         int is_tformat;
  19         int is_alias;
  20         const char *user_format;
  21 } *commit_formats;
  22 static size_t builtin_formats_len;
  23 static size_t commit_formats_len;
  24 static size_t commit_formats_alloc;
  25 static struct cmt_fmt_map *find_commit_format(const char *sought);
  26
  27 int commit_format_is_empty(enum cmit_fmt fmt)
  28 {
  29         return fmt == CMIT_FMT_USERFORMAT && !*user_format;
  30 }
  31
  32 static void save_user_format(struct rev_info *rev, const char *cp, int is_tformat)
  33 {
  34         free(user_format);
  35         user_format = xstrdup(cp);
  36         if (is_tformat)
  37                 rev->use_terminator = 1;
  38         rev->commit_format = CMIT_FMT_USERFORMAT;
  39 }
  40
  41 static int git_pretty_formats_config(const char *var, const char *value, void *cb)
  42 {
  43         struct cmt_fmt_map *commit_format = NULL;
  44         const char *name;
  45         const char *fmt;
  46         int i;
  47
  48         if (!skip_prefix(var, "pretty.", &name))
  49                 return 0;
  50
  51         for (i = 0; i < builtin_formats_len; i++) {
  52                 if (!strcmp(commit_formats[i].name, name))
  53                         return 0;
  54         }
  55
  56         for (i = builtin_formats_len; i < commit_formats_len; i++) {
  57                 if (!strcmp(commit_formats[i].name, name)) {
  58                         commit_format = &commit_formats[i];
  59                         break;
  60                 }
  61         }
  62
  63         if (!commit_format) {
  64                 ALLOC_GROW(commit_formats, commit_formats_len+1,
  65                            commit_formats_alloc);
  66                 commit_format = &commit_formats[commit_formats_len];
  67                 memset(commit_format, 0, sizeof(*commit_format));
  68                 commit_formats_len++;
  69         }
  70
  71         commit_format->name = xstrdup(name);
  72         commit_format->format = CMIT_FMT_USERFORMAT;
  73         if (git_config_string(&fmt, var, value))
  74                 return -1;
  75
  76         if (skip_prefix(fmt, "format:", &fmt))
  77                 commit_format->is_tformat = 0;
  78         else if (skip_prefix(fmt, "tformat:", &fmt) || strchr(fmt, '%'))
  79                 commit_format->is_tformat = 1;
  80         else
  81                 commit_format->is_alias = 1;
  82         commit_format->user_format = fmt;
  83
  84         return 0;
  85 }
  86
  87 static void setup_commit_formats(void)
  88 {
  89         struct cmt_fmt_map builtin_formats[] = {
  90                 { "raw",        CMIT_FMT_RAW,           0 },
  91                 { "medium",     CMIT_FMT_MEDIUM,        0 },
  92                 { "short",      CMIT_FMT_SHORT,         0 },
  93                 { "email",      CMIT_FMT_EMAIL,         0 },
  94                 { "fuller",     CMIT_FMT_FULLER,        0 },
  95                 { "full",       CMIT_FMT_FULL,          0 },
  96                 { "oneline",    CMIT_FMT_ONELINE,       1 }
  97         };
  98         commit_formats_len = ARRAY_SIZE(builtin_formats);
  99         builtin_formats_len = commit_formats_len;
 100         ALLOC_GROW(commit_formats, commit_formats_len, commit_formats_alloc);
 101         memcpy(commit_formats, builtin_formats,
 102                sizeof(*builtin_formats)*ARRAY_SIZE(builtin_formats));
 103
 104         git_config(git_pretty_formats_config, NULL);
 105 }
 106
 107 static struct cmt_fmt_map *find_commit_format_recursive(const char *sought,
 108                                                         const char *original,
 109                                                         int num_redirections)
 110 {
 111         struct cmt_fmt_map *found = NULL;
 112         size_t found_match_len = 0;
 113         int i;
 114
 115         if (num_redirections >= commit_formats_len)
 116                 die("invalid --pretty format: "
 117                     "'%s' references an alias which points to itself",
 118                     original);
 119
 120         for (i = 0; i < commit_formats_len; i++) {
 121                 size_t match_len;
 122
 123                 if (!starts_with(commit_formats[i].name, sought))
 124                         continue;
 125
 126                 match_len = strlen(commit_formats[i].name);
 127                 if (found == NULL || found_match_len > match_len) {
 128                         found = &commit_formats[i];
 129                         found_match_len = match_len;
 130                 }
 131         }
 132
 133         if (found && found->is_alias) {
 134                 found = find_commit_format_recursive(found->user_format,
 135                                                      original,
 136                                                      num_redirections+1);
 137         }
 138
 139         return found;
 140 }
 141
 142 static struct cmt_fmt_map *find_commit_format(const char *sought)
 143 {
 144         if (!commit_formats)
 145                 setup_commit_formats();
 146
 147         return find_commit_format_recursive(sought, sought, 0);
 148 }
 149
 150 void get_commit_format(const char *arg, struct rev_info *rev)
 151 {
 152         struct cmt_fmt_map *commit_format;
 153
 154         rev->use_terminator = 0;
 155         if (!arg) {
 156                 rev->commit_format = CMIT_FMT_DEFAULT;
 157                 return;
 158         }
 159         if (skip_prefix(arg, "format:", &arg)) {
 160                 save_user_format(rev, arg, 0);
 161                 return;
 162         }
 163
 164         if (!*arg || skip_prefix(arg, "tformat:", &arg) || strchr(arg, '%')) {
 165                 save_user_format(rev, arg, 1);
 166                 return;
 167         }
 168
 169         commit_format = find_commit_format(arg);
 170         if (!commit_format)
 171                 die("invalid --pretty format: %s", arg);
 172
 173         rev->commit_format = commit_format->format;
 174         rev->use_terminator = commit_format->is_tformat;
 175         if (commit_format->format == CMIT_FMT_USERFORMAT) {
 176                 save_user_format(rev, commit_format->user_format,
 177                                  commit_format->is_tformat);
 178         }
 179 }
 180
 181 /*
 182  * Generic support for pretty-printing the header
 183  */
 184 static int get_one_line(const char *msg)
 185 {
 186         int ret = 0;
 187
 188         for (;;) {
 189                 char c = *msg++;
 190                 if (!c)
 191                         break;
 192                 ret++;
 193                 if (c == '\n')
 194                         break;
 195         }
 196         return ret;
 197 }
 198
 199 /* High bit set, or ISO-2022-INT */
 200 static int non_ascii(int ch)
 201 {
 202         return !isascii(ch) || ch == '\033';
 203 }
 204
 205 int has_non_ascii(const char *s)
 206 {
 207         int ch;
 208         if (!s)
 209                 return 0;
 210         while ((ch = *s++) != '\0') {
 211                 if (non_ascii(ch))
 212                         return 1;
 213         }
 214         return 0;
 215 }
 216
 217 static int is_rfc822_special(char ch)
 218 {
 219         switch (ch) {
 220         case '(':
 221         case ')':
 222         case '<':
 223         case '>':
 224         case '[':
 225         case ']':
 226         case ':':
 227         case ';':
 228         case '@':
 229         case ',':
 230         case '.':
 231         case '"':
 232         case '\\':
 233                 return 1;
 234         default:
 235                 return 0;
 236         }
 237 }
 238
 239 static int needs_rfc822_quoting(const char *s, int len)
 240 {
 241         int i;
 242         for (i = 0; i < len; i++)
 243                 if (is_rfc822_special(s[i]))
 244                         return 1;
 245         return 0;
 246 }
 247
 248 static int last_line_length(struct strbuf *sb)
 249 {
 250         int i;
 251
 252         /* How many bytes are already used on the last line? */
 253         for (i = sb->len - 1; i >= 0; i--)
 254                 if (sb->buf[i] == '\n')
 255                         break;
 256         return sb->len - (i + 1);
 257 }
 258
 259 static void add_rfc822_quoted(struct strbuf *out, const char *s, int len)
 260 {
 261         int i;
 262
 263         /* just a guess, we may have to also backslash-quote */
 264         strbuf_grow(out, len + 2);
 265
 266         strbuf_addch(out, '"');
 267         for (i = 0; i < len; i++) {
 268                 switch (s[i]) {
 269                 case '"':
 270                 case '\\':
 271                         strbuf_addch(out, '\\');
 272                         /* fall through */
 273                 default:
 274                         strbuf_addch(out, s[i]);
 275                 }
 276         }
 277         strbuf_addch(out, '"');
 278 }
 279
 280 enum rfc2047_type {
 281         RFC2047_SUBJECT,
 282         RFC2047_ADDRESS
 283 };
 284
 285 static int is_rfc2047_special(char ch, enum rfc2047_type type)
 286 {
 287         /*
 288          * rfc2047, section 4.2:
 289          *
 290          *    8-bit values which correspond to printable ASCII characters other
 291          *    than "=", "?", and "_" (underscore), MAY be represented as those
 292          *    characters.  (But see section 5 for restrictions.)  In
 293          *    particular, SPACE and TAB MUST NOT be represented as themselves
 294          *    within encoded words.
 295          */
 296
 297         /*
 298          * rule out non-ASCII characters and non-printable characters (the
 299          * non-ASCII check should be redundant as isprint() is not localized
 300          * and only knows about ASCII, but be defensive about that)
 301          */
 302         if (non_ascii(ch) || !isprint(ch))
 303                 return 1;
 304
 305         /*
 306          * rule out special printable characters (' ' should be the only
 307          * whitespace character considered printable, but be defensive and use
 308          * isspace())
 309          */
 310         if (isspace(ch) || ch == '=' || ch == '?' || ch == '_')
 311                 return 1;
 312
 313         /*
 314          * rfc2047, section 5.3:
 315          *
 316          *    As a replacement for a 'word' entity within a 'phrase', for example,
 317          *    one that precedes an address in a From, To, or Cc header.  The ABNF
 318          *    definition for 'phrase' from RFC 822 thus becomes:
 319          *
 320          *    phrase = 1*( encoded-word / word )
 321          *
 322          *    In this case the set of characters that may be used in a "Q"-encoded
 323          *    'encoded-word' is restricted to: <upper and lower case ASCII
 324          *    letters, decimal digits, "!", "*", "+", "-", "/", "=", and "_"
 325          *    (underscore, ASCII 95.)>.  An 'encoded-word' that appears within a
 326          *    'phrase' MUST be separated from any adjacent 'word', 'text' or
 327          *    'special' by 'linear-white-space'.
 328          */
 329
 330         if (type != RFC2047_ADDRESS)
 331                 return 0;
 332
 333         /* '=' and '_' are special cases and have been checked above */
 334         return !(isalnum(ch) || ch == '!' || ch == '*' || ch == '+' || ch == '-' || ch == '/');
 335 }
 336
 337 static int needs_rfc2047_encoding(const char *line, int len,
 338                                   enum rfc2047_type type)
 339 {
 340         int i;
 341
 342         for (i = 0; i < len; i++) {
 343                 int ch = line[i];
 344                 if (non_ascii(ch) || ch == '\n')
 345                         return 1;
 346                 if ((i + 1 < len) && (ch == '=' && line[i+1] == '?'))
 347                         return 1;
 348         }
 349
 350         return 0;
 351 }
 352
 353 static void add_rfc2047(struct strbuf *sb, const char *line, size_t len,
 354                        const char *encoding, enum rfc2047_type type)
 355 {
 356         static const int max_encoded_length = 76; /* per rfc2047 */
 357         int i;
 358         int line_len = last_line_length(sb);
 359
 360         strbuf_grow(sb, len * 3 + strlen(encoding) + 100);
 361         strbuf_addf(sb, "=?%s?q?", encoding);
 362         line_len += strlen(encoding) + 5; /* 5 for =??q? */
 363
 364         while (len) {
 365                 /*
 366                  * RFC 2047, section 5 (3):
 367                  *
 368                  * Each 'encoded-word' MUST represent an integral number of
 369                  * characters.  A multi-octet character may not be split across
 370                  * adjacent 'encoded- word's.
 371                  */
 372                 const unsigned char *p = (const unsigned char *)line;
 373                 int chrlen = mbs_chrlen(&line, &len, encoding);
 374                 int is_special = (chrlen > 1) || is_rfc2047_special(*p, type);
 375
 376                 /* "=%02X" * chrlen, or the byte itself */
 377                 const char *encoded_fmt = is_special ? "=%02X"    : "%c";
 378                 int         encoded_len = is_special ? 3 * chrlen : 1;
 379
 380                 /*
 381                  * According to RFC 2047, we could encode the special character
 382                  * ' ' (space) with '_' (underscore) for readability. But many
 383                  * programs do not understand this and just leave the
 384                  * underscore in place. Thus, we do nothing special here, which
 385                  * causes ' ' to be encoded as '=20', avoiding this problem.
 386                  */
 387
 388                 if (line_len + encoded_len + 2 > max_encoded_length) {
 389                         /* It won't fit with trailing "?=" --- break the line */
 390                         strbuf_addf(sb, "?=\n =?%s?q?", encoding);
 391                         line_len = strlen(encoding) + 5 + 1; /* =??q? plus SP */
 392                 }
 393
 394                 for (i = 0; i < chrlen; i++)
 395                         strbuf_addf(sb, encoded_fmt, p[i]);
 396                 line_len += encoded_len;
 397         }
 398         strbuf_addstr(sb, "?=");
 399 }
 400
 401 const char *show_ident_date(const struct ident_split *ident,
 402                             const struct date_mode *mode)
 403 {
 404         unsigned long date = 0;
 405         long tz = 0;
 406
 407         if (ident->date_begin && ident->date_end)
 408                 date = strtoul(ident->date_begin, NULL, 10);
 409         if (date_overflows(date))
 410                 date = 0;
 411         else {
 412                 if (ident->tz_begin && ident->tz_end)
 413                         tz = strtol(ident->tz_begin, NULL, 10);
 414                 if (tz >= INT_MAX || tz <= INT_MIN)
 415                         tz = 0;
 416         }
 417         return show_date(date, tz, mode);
 418 }
 419
 420 void pp_user_info(struct pretty_print_context *pp,
 421                   const char *what, struct strbuf *sb,
 422                   const char *line, const char *encoding)
 423 {
 424         struct ident_split ident;
 425         char *line_end;
 426         const char *mailbuf, *namebuf;
 427         size_t namelen, maillen;
 428         int max_length = 78; /* per rfc2822 */
 429
 430         if (pp->fmt == CMIT_FMT_ONELINE)
 431                 return;
 432
 433         line_end = strchrnul(line, '\n');
 434         if (split_ident_line(&ident, line, line_end - line))
 435                 return;
 436
 437         mailbuf = ident.mail_begin;
 438         maillen = ident.mail_end - ident.mail_begin;
 439         namebuf = ident.name_begin;
 440         namelen = ident.name_end - ident.name_begin;
 441
 442         if (pp->mailmap)
 443                 map_user(pp->mailmap, &mailbuf, &maillen, &namebuf, &namelen);
 444
 445         if (pp->fmt == CMIT_FMT_EMAIL) {
 446                 if (pp->from_ident && ident_cmp(pp->from_ident, &ident)) {
 447                         struct strbuf buf = STRBUF_INIT;
 448
 449                         strbuf_addstr(&buf, "From: ");
 450                         strbuf_add(&buf, namebuf, namelen);
 451                         strbuf_addstr(&buf, " <");
 452                         strbuf_add(&buf, mailbuf, maillen);
 453                         strbuf_addstr(&buf, ">\n");
 454                         string_list_append(&pp->in_body_headers,
 455                                            strbuf_detach(&buf, NULL));
 456
 457                         mailbuf = pp->from_ident->mail_begin;
 458                         maillen = pp->from_ident->mail_end - mailbuf;
 459                         namebuf = pp->from_ident->name_begin;
 460                         namelen = pp->from_ident->name_end - namebuf;
 461                 }
 462
 463                 strbuf_addstr(sb, "From: ");
 464                 if (needs_rfc2047_encoding(namebuf, namelen, RFC2047_ADDRESS)) {
 465                         add_rfc2047(sb, namebuf, namelen,
 466                                     encoding, RFC2047_ADDRESS);
 467                         max_length = 76; /* per rfc2047 */
 468                 } else if (needs_rfc822_quoting(namebuf, namelen)) {
 469                         struct strbuf quoted = STRBUF_INIT;
 470                         add_rfc822_quoted(&quoted, namebuf, namelen);
 471                         strbuf_add_wrapped_bytes(sb, quoted.buf, quoted.len,
 472                                                         -6, 1, max_length);
 473                         strbuf_release(&quoted);
 474                 } else {
 475                         strbuf_add_wrapped_bytes(sb, namebuf, namelen,
 476                                                  -6, 1, max_length);
 477                 }
 478
 479                 if (max_length <
 480                     last_line_length(sb) + strlen(" <") + maillen + strlen(">"))
 481                         strbuf_addch(sb, '\n');
 482                 strbuf_addf(sb, " <%.*s>\n", (int)maillen, mailbuf);
 483         } else {
 484                 strbuf_addf(sb, "%s: %.*s%.*s <%.*s>\n", what,
 485                             (pp->fmt == CMIT_FMT_FULLER) ? 4 : 0, "    ",
 486                             (int)namelen, namebuf, (int)maillen, mailbuf);
 487         }
 488
 489         switch (pp->fmt) {
 490         case CMIT_FMT_MEDIUM:
 491                 strbuf_addf(sb, "Date:   %s\n",
 492                             show_ident_date(&ident, &pp->date_mode));
 493                 break;
 494         case CMIT_FMT_EMAIL:
 495                 strbuf_addf(sb, "Date: %s\n",
 496                             show_ident_date(&ident, DATE_MODE(RFC2822)));
 497                 break;
 498         case CMIT_FMT_FULLER:
 499                 strbuf_addf(sb, "%sDate: %s\n", what,
 500                             show_ident_date(&ident, &pp->date_mode));
 501                 break;
 502         default:
 503                 /* notin' */
 504                 break;
 505         }
 506 }
 507
 508 static int is_empty_line(const char *line, int *len_p)
 509 {
 510         int len = *len_p;
 511         while (len && isspace(line[len - 1]))
 512                 len--;
 513         *len_p = len;
 514         return !len;
 515 }
 516
 517 static const char *skip_empty_lines(const char *msg)
 518 {
 519         for (;;) {
 520                 int linelen = get_one_line(msg);
 521                 int ll = linelen;
 522                 if (!linelen)
 523                         break;
 524                 if (!is_empty_line(msg, &ll))
 525                         break;
 526                 msg += linelen;
 527         }
 528         return msg;
 529 }
 530
 531 static void add_merge_info(const struct pretty_print_context *pp,
 532                            struct strbuf *sb, const struct commit *commit)
 533 {
 534         struct commit_list *parent = commit->parents;
 535
 536         if ((pp->fmt == CMIT_FMT_ONELINE) || (pp->fmt == CMIT_FMT_EMAIL) ||
 537             !parent || !parent->next)
 538                 return;
 539
 540         strbuf_addstr(sb, "Merge:");
 541
 542         while (parent) {
 543                 struct commit *p = parent->item;
 544                 const char *hex = NULL;
 545                 if (pp->abbrev)
 546                         hex = find_unique_abbrev(p->object.sha1, pp->abbrev);
 547                 if (!hex)
 548                         hex = sha1_to_hex(p->object.sha1);
 549                 parent = parent->next;
 550
 551                 strbuf_addf(sb, " %s", hex);
 552         }
 553         strbuf_addch(sb, '\n');
 554 }
 555
 556 static char *get_header(const char *msg, const char *key)
 557 {
 558         size_t len;
 559         const char *v = find_commit_header(msg, key, &len);
 560         return v ? xmemdupz(v, len) : NULL;
 561 }
 562
 563 static char *replace_encoding_header(char *buf, const char *encoding)
 564 {
 565         struct strbuf tmp = STRBUF_INIT;
 566         size_t start, len;
 567         char *cp = buf;
 568
 569         /* guess if there is an encoding header before a \n\n */
 570         while (!starts_with(cp, "encoding ")) {
 571                 cp = strchr(cp, '\n');
 572                 if (!cp || *++cp == '\n')
 573                         return buf;
 574         }
 575         start = cp - buf;
 576         cp = strchr(cp, '\n');
 577         if (!cp)
 578                 return buf; /* should not happen but be defensive */
 579         len = cp + 1 - (buf + start);
 580
 581         strbuf_attach(&tmp, buf, strlen(buf), strlen(buf) + 1);
 582         if (is_encoding_utf8(encoding)) {
 583                 /* we have re-coded to UTF-8; drop the header */
 584                 strbuf_remove(&tmp, start, len);
 585         } else {
 586                 /* just replaces XXXX in 'encoding XXXX\n' */
 587                 strbuf_splice(&tmp, start + strlen("encoding "),
 588                                           len - strlen("encoding \n"),
 589                                           encoding, strlen(encoding));
 590         }
 591         return strbuf_detach(&tmp, NULL);
 592 }
 593
 594 const char *logmsg_reencode(const struct commit *commit,
 595                             char **commit_encoding,
 596                             const char *output_encoding)
 597 {
 598         static const char *utf8 = "UTF-8";
 599         const char *use_encoding;
 600         char *encoding;
 601         const char *msg = get_commit_buffer(commit, NULL);
 602         char *out;
 603
 604         if (!output_encoding || !*output_encoding) {
 605                 if (commit_encoding)
 606                         *commit_encoding = get_header(msg, "encoding");
 607                 return msg;
 608         }
 609         encoding = get_header(msg, "encoding");
 610         if (commit_encoding)
 611                 *commit_encoding = encoding;
 612         use_encoding = encoding ? encoding : utf8;
 613         if (same_encoding(use_encoding, output_encoding)) {
 614                 /*
 615                  * No encoding work to be done. If we have no encoding header
 616                  * at all, then there's nothing to do, and we can return the
 617                  * message verbatim (whether newly allocated or not).
 618                  */
 619                 if (!encoding)
 620                         return msg;
 621
 622                 /*
 623                  * Otherwise, we still want to munge the encoding header in the
 624                  * result, which will be done by modifying the buffer. If we
 625                  * are using a fresh copy, we can reuse it. But if we are using
 626                  * the cached copy from get_commit_buffer, we need to duplicate it
 627                  * to avoid munging the cached copy.
 628                  */
 629                 if (msg == get_cached_commit_buffer(commit, NULL))
 630                         out = xstrdup(msg);
 631                 else
 632                         out = (char *)msg;
 633         }
 634         else {
 635                 /*
 636                  * There's actual encoding work to do. Do the reencoding, which
 637                  * still leaves the header to be replaced in the next step. At
 638                  * this point, we are done with msg. If we allocated a fresh
 639                  * copy, we can free it.
 640                  */
 641                 out = reencode_string(msg, output_encoding, use_encoding);
 642                 if (out)
 643                         unuse_commit_buffer(commit, msg);
 644         }
 645
 646         /*
 647          * This replacement actually consumes the buffer we hand it, so we do
 648          * not have to worry about freeing the old "out" here.
 649          */
 650         if (out)
 651                 out = replace_encoding_header(out, output_encoding);
 652
 653         if (!commit_encoding)
 654                 free(encoding);
 655         /*
 656          * If the re-encoding failed, out might be NULL here; in that
 657          * case we just return the commit message verbatim.
 658          */
 659         return out ? out : msg;
 660 }
 661
 662 static int mailmap_name(const char **email, size_t *email_len,
 663                         const char **name, size_t *name_len)
 664 {
 665         static struct string_list *mail_map;
 666         if (!mail_map) {
 667                 mail_map = xcalloc(1, sizeof(*mail_map));
 668                 read_mailmap(mail_map, NULL);
 669         }
 670         return mail_map->nr && map_user(mail_map, email, email_len, name, name_len);
 671 }
 672
 673 static size_t format_person_part(struct strbuf *sb, char part,
 674                                  const char *msg, int len,
 675                                  const struct date_mode *dmode)
 676 {
 677         /* currently all placeholders have same length */
 678         const int placeholder_len = 2;
 679         struct ident_split s;
 680         const char *name, *mail;
 681         size_t maillen, namelen;
 682
 683         if (split_ident_line(&s, msg, len) < 0)
 684                 goto skip;
 685
 686         name = s.name_begin;
 687         namelen = s.name_end - s.name_begin;
 688         mail = s.mail_begin;
 689         maillen = s.mail_end - s.mail_begin;
 690
 691         if (part == 'N' || part == 'E') /* mailmap lookup */
 692                 mailmap_name(&mail, &maillen, &name, &namelen);
 693         if (part == 'n' || part == 'N') {       /* name */
 694                 strbuf_add(sb, name, namelen);
 695                 return placeholder_len;
 696         }
 697         if (part == 'e' || part == 'E') {       /* email */
 698                 strbuf_add(sb, mail, maillen);
 699                 return placeholder_len;
 700         }
 701
 702         if (!s.date_begin)
 703                 goto skip;
 704
 705         if (part == 't') {      /* date, UNIX timestamp */
 706                 strbuf_add(sb, s.date_begin, s.date_end - s.date_begin);
 707                 return placeholder_len;
 708         }
 709
 710         switch (part) {
 711         case 'd':       /* date */
 712                 strbuf_addstr(sb, show_ident_date(&s, dmode));
 713                 return placeholder_len;
 714         case 'D':       /* date, RFC2822 style */
 715                 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(RFC2822)));
 716                 return placeholder_len;
 717         case 'r':       /* date, relative */
 718                 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(RELATIVE)));
 719                 return placeholder_len;
 720         case 'i':       /* date, ISO 8601-like */
 721                 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(ISO8601)));
 722                 return placeholder_len;
 723         case 'I':       /* date, ISO 8601 strict */
 724                 strbuf_addstr(sb, show_ident_date(&s, DATE_MODE(ISO8601_STRICT)));
 725                 return placeholder_len;
 726         }
 727
 728 skip:
 729         /*
 730          * reading from either a bogus commit, or a reflog entry with
 731          * %gn, %ge, etc.; 'sb' cannot be updated, but we still need
 732          * to compute a valid return value.
 733          */
 734         if (part == 'n' || part == 'e' || part == 't' || part == 'd'
 735             || part == 'D' || part == 'r' || part == 'i')
 736                 return placeholder_len;
 737
 738         return 0; /* unknown placeholder */
 739 }
 740
 741 struct chunk {
 742         size_t off;
 743         size_t len;
 744 };
 745
 746 enum flush_type {
 747         no_flush,
 748         flush_right,
 749         flush_left,
 750         flush_left_and_steal,
 751         flush_both
 752 };
 753
 754 enum trunc_type {
 755         trunc_none,
 756         trunc_left,
 757         trunc_middle,
 758         trunc_right
 759 };
 760
 761 struct format_commit_context {
 762         const struct commit *commit;
 763         const struct pretty_print_context *pretty_ctx;
 764         unsigned commit_header_parsed:1;
 765         unsigned commit_message_parsed:1;
 766         struct signature_check signature_check;
 767         enum flush_type flush_type;
 768         enum trunc_type truncate;
 769         const char *message;
 770         char *commit_encoding;
 771         size_t width, indent1, indent2;
 772         int auto_color;
 773         int padding;
 774
 775         /* These offsets are relative to the start of the commit message. */
 776         struct chunk author;
 777         struct chunk committer;
 778         size_t message_off;
 779         size_t subject_off;
 780         size_t body_off;
 781
 782         /* The following ones are relative to the result struct strbuf. */
 783         struct chunk abbrev_commit_hash;
 784         struct chunk abbrev_tree_hash;
 785         struct chunk abbrev_parent_hashes;
 786         size_t wrap_start;
 787 };
 788
 789 static int add_again(struct strbuf *sb, struct chunk *chunk)
 790 {
 791         if (chunk->len) {
 792                 strbuf_adddup(sb, chunk->off, chunk->len);
 793                 return 1;
 794         }
 795
 796         /*
 797          * We haven't seen this chunk before.  Our caller is surely
 798          * going to add it the hard way now.  Remember the most likely
 799          * start of the to-be-added chunk: the current end of the
 800          * struct strbuf.
 801          */
 802         chunk->off = sb->len;
 803         return 0;
 804 }
 805
 806 static void parse_commit_header(struct format_commit_context *context)
 807 {
 808         const char *msg = context->message;
 809         int i;
 810
 811         for (i = 0; msg[i]; i++) {
 812                 const char *name;
 813                 int eol;
 814                 for (eol = i; msg[eol] && msg[eol] != '\n'; eol++)
 815                         ; /* do nothing */
 816
 817                 if (i == eol) {
 818                         break;
 819                 } else if (skip_prefix(msg + i, "author ", &name)) {
 820                         context->author.off = name - msg;
 821                         context->author.len = msg + eol - name;
 822                 } else if (skip_prefix(msg + i, "committer ", &name)) {
 823                         context->committer.off = name - msg;
 824                         context->committer.len = msg + eol - name;
 825                 }
 826                 i = eol;
 827         }
 828         context->message_off = i;
 829         context->commit_header_parsed = 1;
 830 }
 831
 832 static int istitlechar(char c)
 833 {
 834         return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
 835                 (c >= '0' && c <= '9') || c == '.' || c == '_';
 836 }
 837
 838 static void format_sanitized_subject(struct strbuf *sb, const char *msg)
 839 {
 840         size_t trimlen;
 841         size_t start_len = sb->len;
 842         int space = 2;
 843
 844         for (; *msg && *msg != '\n'; msg++) {
 845                 if (istitlechar(*msg)) {
 846                         if (space == 1)
 847                                 strbuf_addch(sb, '-');
 848                         space = 0;
 849                         strbuf_addch(sb, *msg);
 850                         if (*msg == '.')
 851                                 while (*(msg+1) == '.')
 852                                         msg++;
 853                 } else
 854                         space |= 1;
 855         }
 856
 857         /* trim any trailing '.' or '-' characters */
 858         trimlen = 0;
 859         while (sb->len - trimlen > start_len &&
 860                 (sb->buf[sb->len - 1 - trimlen] == '.'
 861                 || sb->buf[sb->len - 1 - trimlen] == '-'))
 862                 trimlen++;
 863         strbuf_remove(sb, sb->len - trimlen, trimlen);
 864 }
 865
 866 const char *format_subject(struct strbuf *sb, const char *msg,
 867                            const char *line_separator)
 868 {
 869         int first = 1;
 870
 871         for (;;) {
 872                 const char *line = msg;
 873                 int linelen = get_one_line(line);
 874
 875                 msg += linelen;
 876                 if (!linelen || is_empty_line(line, &linelen))
 877                         break;
 878
 879                 if (!sb)
 880                         continue;
 881                 strbuf_grow(sb, linelen + 2);
 882                 if (!first)
 883                         strbuf_addstr(sb, line_separator);
 884                 strbuf_add(sb, line, linelen);
 885                 first = 0;
 886         }
 887         return msg;
 888 }
 889
 890 static void parse_commit_message(struct format_commit_context *c)
 891 {
 892         const char *msg = c->message + c->message_off;
 893         const char *start = c->message;
 894
 895         msg = skip_empty_lines(msg);
 896         c->subject_off = msg - start;
 897
 898         msg = format_subject(NULL, msg, NULL);
 899         msg = skip_empty_lines(msg);
 900         c->body_off = msg - start;
 901
 902         c->commit_message_parsed = 1;
 903 }
 904
 905 static void strbuf_wrap(struct strbuf *sb, size_t pos,
 906                         size_t width, size_t indent1, size_t indent2)
 907 {
 908         struct strbuf tmp = STRBUF_INIT;
 909
 910         if (pos)
 911                 strbuf_add(&tmp, sb->buf, pos);
 912         strbuf_add_wrapped_text(&tmp, sb->buf + pos,
 913                                 (int) indent1, (int) indent2, (int) width);
 914         strbuf_swap(&tmp, sb);
 915         strbuf_release(&tmp);
 916 }
 917
 918 static void rewrap_message_tail(struct strbuf *sb,
 919                                 struct format_commit_context *c,
 920                                 size_t new_width, size_t new_indent1,
 921                                 size_t new_indent2)
 922 {
 923         if (c->width == new_width && c->indent1 == new_indent1 &&
 924             c->indent2 == new_indent2)
 925                 return;
 926         if (c->wrap_start < sb->len)
 927                 strbuf_wrap(sb, c->wrap_start, c->width, c->indent1, c->indent2);
 928         c->wrap_start = sb->len;
 929         c->width = new_width;
 930         c->indent1 = new_indent1;
 931         c->indent2 = new_indent2;
 932 }
 933
 934 static int format_reflog_person(struct strbuf *sb,
 935                                 char part,
 936                                 struct reflog_walk_info *log,
 937                                 const struct date_mode *dmode)
 938 {
 939         const char *ident;
 940
 941         if (!log)
 942                 return 2;
 943
 944         ident = get_reflog_ident(log);
 945         if (!ident)
 946                 return 2;
 947
 948         return format_person_part(sb, part, ident, strlen(ident), dmode);
 949 }
 950
 951 static size_t parse_color(struct strbuf *sb, /* in UTF-8 */
 952                           const char *placeholder,
 953                           struct format_commit_context *c)
 954 {
 955         const char *rest = placeholder;
 956
 957         if (placeholder[1] == '(') {
 958                 const char *begin = placeholder + 2;
 959                 const char *end = strchr(begin, ')');
 960                 char color[COLOR_MAXLEN];
 961
 962                 if (!end)
 963                         return 0;
 964                 if (skip_prefix(begin, "auto,", &begin)) {
 965                         if (!want_color(c->pretty_ctx->color))
 966                                 return end - placeholder + 1;
 967                 }
 968                 if (color_parse_mem(begin, end - begin, color) < 0)
 969                         die(_("unable to parse --pretty format"));
 970                 strbuf_addstr(sb, color);
 971                 return end - placeholder + 1;
 972         }
 973         if (skip_prefix(placeholder + 1, "red", &rest))
 974                 strbuf_addstr(sb, GIT_COLOR_RED);
 975         else if (skip_prefix(placeholder + 1, "green", &rest))
 976                 strbuf_addstr(sb, GIT_COLOR_GREEN);
 977         else if (skip_prefix(placeholder + 1, "blue", &rest))
 978                 strbuf_addstr(sb, GIT_COLOR_BLUE);
 979         else if (skip_prefix(placeholder + 1, "reset", &rest))
 980                 strbuf_addstr(sb, GIT_COLOR_RESET);
 981         return rest - placeholder;
 982 }
 983
 984 static size_t parse_padding_placeholder(struct strbuf *sb,
 985                                         const char *placeholder,
 986                                         struct format_commit_context *c)
 987 {
 988         const char *ch = placeholder;
 989         enum flush_type flush_type;
 990         int to_column = 0;
 991
 992         switch (*ch++) {
 993         case '<':
 994                 flush_type = flush_right;
 995                 break;
 996         case '>':
 997                 if (*ch == '<') {
 998                         flush_type = flush_both;
 999                         ch++;
1000                 } else if (*ch == '>') {
1001                         flush_type = flush_left_and_steal;
1002                         ch++;
1003                 } else
1004                         flush_type = flush_left;
1005                 break;
1006         default:
1007                 return 0;
1008         }
1009
1010         /* the next value means "wide enough to that column" */
1011         if (*ch == '|') {
1012                 to_column = 1;
1013                 ch++;
1014         }
1015
1016         if (*ch == '(') {
1017                 const char *start = ch + 1;
1018                 const char *end = start + strcspn(start, ",)");
1019                 char *next;
1020                 int width;
1021                 if (!end || end == start)
1022                         return 0;
1023                 width = strtoul(start, &next, 10);
1024                 if (next == start || width == 0)
1025                         return 0;
1026                 c->padding = to_column ? -width : width;
1027                 c->flush_type = flush_type;
1028
1029                 if (*end == ',') {
1030                         start = end + 1;
1031                         end = strchr(start, ')');
1032                         if (!end || end == start)
1033                                 return 0;
1034                         if (starts_with(start, "trunc)"))
1035                                 c->truncate = trunc_right;
1036                         else if (starts_with(start, "ltrunc)"))
1037                                 c->truncate = trunc_left;
1038                         else if (starts_with(start, "mtrunc)"))
1039                                 c->truncate = trunc_middle;
1040                         else
1041                                 return 0;
1042                 } else
1043                         c->truncate = trunc_none;
1044
1045                 return end - placeholder + 1;
1046         }
1047         return 0;
1048 }
1049
1050 static size_t format_commit_one(struct strbuf *sb, /* in UTF-8 */
1051                                 const char *placeholder,
1052                                 void *context)
1053 {
1054         struct format_commit_context *c = context;
1055         const struct commit *commit = c->commit;
1056         const char *msg = c->message;
1057         struct commit_list *p;
1058         int h1, h2;
1059
1060         /* these are independent of the commit */
1061         switch (placeholder[0]) {
1062         case 'C':
1063                 if (starts_with(placeholder + 1, "(auto)")) {
1064                         c->auto_color = 1;
1065                         return 7; /* consumed 7 bytes, "C(auto)" */
1066                 } else {
1067                         int ret = parse_color(sb, placeholder, c);
1068                         if (ret)
1069                                 c->auto_color = 0;
1070                         /*
1071                          * Otherwise, we decided to treat %C<unknown>
1072                          * as a literal string, and the previous
1073                          * %C(auto) is still valid.
1074                          */
1075                         return ret;
1076                 }
1077         case 'n':               /* newline */
1078                 strbuf_addch(sb, '\n');
1079                 return 1;
1080         case 'x':
1081                 /* %x00 == NUL, %x0a == LF, etc. */
1082                 if (0 <= (h1 = hexval_table[0xff & placeholder[1]]) &&
1083                     h1 <= 16 &&
1084                     0 <= (h2 = hexval_table[0xff & placeholder[2]]) &&
1085                     h2 <= 16) {
1086                         strbuf_addch(sb, (h1<<4)|h2);
1087                         return 3;
1088                 } else
1089                         return 0;
1090         case 'w':
1091                 if (placeholder[1] == '(') {
1092                         unsigned long width = 0, indent1 = 0, indent2 = 0;
1093                         char *next;
1094                         const char *start = placeholder + 2;
1095                         const char *end = strchr(start, ')');
1096                         if (!end)
1097                                 return 0;
1098                         if (end > start) {
1099                                 width = strtoul(start, &next, 10);
1100                                 if (*next == ',') {
1101                                         indent1 = strtoul(next + 1, &next, 10);
1102                                         if (*next == ',') {
1103                                                 indent2 = strtoul(next + 1,
1104                                                                  &next, 10);
1105                                         }
1106                                 }
1107                                 if (*next != ')')
1108                                         return 0;
1109                         }
1110                         rewrap_message_tail(sb, c, width, indent1, indent2);
1111                         return end - placeholder + 1;
1112                 } else
1113                         return 0;
1114
1115         case '<':
1116         case '>':
1117                 return parse_padding_placeholder(sb, placeholder, c);
1118         }
1119
1120         /* these depend on the commit */
1121         if (!commit->object.parsed)
1122                 parse_object(commit->object.sha1);
1123
1124         switch (placeholder[0]) {
1125         case 'H':               /* commit hash */
1126                 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_COMMIT));
1127                 strbuf_addstr(sb, sha1_to_hex(commit->object.sha1));
1128                 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
1129                 return 1;
1130         case 'h':               /* abbreviated commit hash */
1131                 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_COMMIT));
1132                 if (add_again(sb, &c->abbrev_commit_hash)) {
1133                         strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
1134                         return 1;
1135                 }
1136                 strbuf_addstr(sb, find_unique_abbrev(commit->object.sha1,
1137                                                      c->pretty_ctx->abbrev));
1138                 strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
1139                 c->abbrev_commit_hash.len = sb->len - c->abbrev_commit_hash.off;
1140                 return 1;
1141         case 'T':               /* tree hash */
1142                 strbuf_addstr(sb, sha1_to_hex(commit->tree->object.sha1));
1143                 return 1;
1144         case 't':               /* abbreviated tree hash */
1145                 if (add_again(sb, &c->abbrev_tree_hash))
1146                         return 1;
1147                 strbuf_addstr(sb, find_unique_abbrev(commit->tree->object.sha1,
1148                                                      c->pretty_ctx->abbrev));
1149                 c->abbrev_tree_hash.len = sb->len - c->abbrev_tree_hash.off;
1150                 return 1;
1151         case 'P':               /* parent hashes */
1152                 for (p = commit->parents; p; p = p->next) {
1153                         if (p != commit->parents)
1154                                 strbuf_addch(sb, ' ');
1155                         strbuf_addstr(sb, sha1_to_hex(p->item->object.sha1));
1156                 }
1157                 return 1;
1158         case 'p':               /* abbreviated parent hashes */
1159                 if (add_again(sb, &c->abbrev_parent_hashes))
1160                         return 1;
1161                 for (p = commit->parents; p; p = p->next) {
1162                         if (p != commit->parents)
1163                                 strbuf_addch(sb, ' ');
1164                         strbuf_addstr(sb, find_unique_abbrev(
1165                                         p->item->object.sha1,
1166                                         c->pretty_ctx->abbrev));
1167                 }
1168                 c->abbrev_parent_hashes.len = sb->len -
1169                                               c->abbrev_parent_hashes.off;
1170                 return 1;
1171         case 'm':               /* left/right/bottom */
1172                 strbuf_addstr(sb, get_revision_mark(NULL, commit));
1173                 return 1;
1174         case 'd':
1175                 load_ref_decorations(DECORATE_SHORT_REFS);
1176                 format_decorations(sb, commit, c->auto_color);
1177                 return 1;
1178         case 'D':
1179                 load_ref_decorations(DECORATE_SHORT_REFS);
1180                 format_decorations_extended(sb, commit, c->auto_color, "", ", ", "");
1181                 return 1;
1182         case 'g':               /* reflog info */
1183                 switch(placeholder[1]) {
1184                 case 'd':       /* reflog selector */
1185                 case 'D':
1186                         if (c->pretty_ctx->reflog_info)
1187                                 get_reflog_selector(sb,
1188                                                     c->pretty_ctx->reflog_info,
1189                                                     &c->pretty_ctx->date_mode,
1190                                                     c->pretty_ctx->date_mode_explicit,
1191                                                     (placeholder[1] == 'd'));
1192                         return 2;
1193                 case 's':       /* reflog message */
1194                         if (c->pretty_ctx->reflog_info)
1195                                 get_reflog_message(sb, c->pretty_ctx->reflog_info);
1196                         return 2;
1197                 case 'n':
1198                 case 'N':
1199                 case 'e':
1200                 case 'E':
1201                         return format_reflog_person(sb,
1202                                                     placeholder[1],
1203                                                     c->pretty_ctx->reflog_info,
1204                                                     &c->pretty_ctx->date_mode);
1205                 }
1206                 return 0;       /* unknown %g placeholder */
1207         case 'N':
1208                 if (c->pretty_ctx->notes_message) {
1209                         strbuf_addstr(sb, c->pretty_ctx->notes_message);
1210                         return 1;
1211                 }
1212                 return 0;
1213         }
1214
1215         if (placeholder[0] == 'G') {
1216                 if (!c->signature_check.result)
1217                         check_commit_signature(c->commit, &(c->signature_check));
1218                 switch (placeholder[1]) {
1219                 case 'G':
1220                         if (c->signature_check.gpg_output)
1221                                 strbuf_addstr(sb, c->signature_check.gpg_output);
1222                         break;
1223                 case '?':
1224                         switch (c->signature_check.result) {
1225                         case 'G':
1226                         case 'B':
1227                         case 'U':
1228                         case 'N':
1229                                 strbuf_addch(sb, c->signature_check.result);
1230                         }
1231                         break;
1232                 case 'S':
1233                         if (c->signature_check.signer)
1234                                 strbuf_addstr(sb, c->signature_check.signer);
1235                         break;
1236                 case 'K':
1237                         if (c->signature_check.key)
1238                                 strbuf_addstr(sb, c->signature_check.key);
1239                         break;
1240                 default:
1241                         return 0;
1242                 }
1243                 return 2;
1244         }
1245
1246
1247         /* For the rest we have to parse the commit header. */
1248         if (!c->commit_header_parsed)
1249                 parse_commit_header(c);
1250
1251         switch (placeholder[0]) {
1252         case 'a':       /* author ... */
1253                 return format_person_part(sb, placeholder[1],
1254                                    msg + c->author.off, c->author.len,
1255                                    &c->pretty_ctx->date_mode);
1256         case 'c':       /* committer ... */
1257                 return format_person_part(sb, placeholder[1],
1258                                    msg + c->committer.off, c->committer.len,
1259                                    &c->pretty_ctx->date_mode);
1260         case 'e':       /* encoding */
1261                 if (c->commit_encoding)
1262                         strbuf_addstr(sb, c->commit_encoding);
1263                 return 1;
1264         case 'B':       /* raw body */
1265                 /* message_off is always left at the initial newline */
1266                 strbuf_addstr(sb, msg + c->message_off + 1);
1267                 return 1;
1268         }
1269
1270         /* Now we need to parse the commit message. */
1271         if (!c->commit_message_parsed)
1272                 parse_commit_message(c);
1273
1274         switch (placeholder[0]) {
1275         case 's':       /* subject */
1276                 format_subject(sb, msg + c->subject_off, " ");
1277                 return 1;
1278         case 'f':       /* sanitized subject */
1279                 format_sanitized_subject(sb, msg + c->subject_off);
1280                 return 1;
1281         case 'b':       /* body */
1282                 strbuf_addstr(sb, msg + c->body_off);
1283                 return 1;
1284         }
1285         return 0;       /* unknown placeholder */
1286 }
1287
1288 static size_t format_and_pad_commit(struct strbuf *sb, /* in UTF-8 */
1289                                     const char *placeholder,
1290                                     struct format_commit_context *c)
1291 {
1292         struct strbuf local_sb = STRBUF_INIT;
1293         int total_consumed = 0, len, padding = c->padding;
1294         if (padding < 0) {
1295                 const char *start = strrchr(sb->buf, '\n');
1296                 int occupied;
1297                 if (!start)
1298                         start = sb->buf;
1299                 occupied = utf8_strnwidth(start, -1, 1);
1300                 padding = (-padding) - occupied;
1301         }
1302         while (1) {
1303                 int modifier = *placeholder == 'C';
1304                 int consumed = format_commit_one(&local_sb, placeholder, c);
1305                 total_consumed += consumed;
1306
1307                 if (!modifier)
1308                         break;
1309
1310                 placeholder += consumed;
1311                 if (*placeholder != '%')
1312                         break;
1313                 placeholder++;
1314                 total_consumed++;
1315         }
1316         len = utf8_strnwidth(local_sb.buf, -1, 1);
1317
1318         if (c->flush_type == flush_left_and_steal) {
1319                 const char *ch = sb->buf + sb->len - 1;
1320                 while (len > padding && ch > sb->buf) {
1321                         const char *p;
1322                         if (*ch == ' ') {
1323                                 ch--;
1324                                 padding++;
1325                                 continue;
1326                         }
1327                         /* check for trailing ansi sequences */
1328                         if (*ch != 'm')
1329                                 break;
1330                         p = ch - 1;
1331                         while (ch - p < 10 && *p != '\033')
1332                                 p--;
1333                         if (*p != '\033' ||
1334                             ch + 1 - p != display_mode_esc_sequence_len(p))
1335                                 break;
1336                         /*
1337                          * got a good ansi sequence, put it back to
1338                          * local_sb as we're cutting sb
1339                          */
1340                         strbuf_insert(&local_sb, 0, p, ch + 1 - p);
1341                         ch = p - 1;
1342                 }
1343                 strbuf_setlen(sb, ch + 1 - sb->buf);
1344                 c->flush_type = flush_left;
1345         }
1346
1347         if (len > padding) {
1348                 switch (c->truncate) {
1349                 case trunc_left:
1350                         strbuf_utf8_replace(&local_sb,
1351                                             0, len - (padding - 2),
1352                                             "..");
1353                         break;
1354                 case trunc_middle:
1355                         strbuf_utf8_replace(&local_sb,
1356                                             padding / 2 - 1,
1357                                             len - (padding - 2),
1358                                             "..");
1359                         break;
1360                 case trunc_right:
1361                         strbuf_utf8_replace(&local_sb,
1362                                             padding - 2, len - (padding - 2),
1363                                             "..");
1364                         break;
1365                 case trunc_none:
1366                         break;
1367                 }
1368                 strbuf_addbuf(sb, &local_sb);
1369         } else {
1370                 int sb_len = sb->len, offset = 0;
1371                 if (c->flush_type == flush_left)
1372                         offset = padding - len;
1373                 else if (c->flush_type == flush_both)
1374                         offset = (padding - len) / 2;
1375                 /*
1376                  * we calculate padding in columns, now
1377                  * convert it back to chars
1378                  */
1379                 padding = padding - len + local_sb.len;
1380                 strbuf_addchars(sb, ' ', padding);
1381                 memcpy(sb->buf + sb_len + offset, local_sb.buf,
1382                        local_sb.len);
1383         }
1384         strbuf_release(&local_sb);
1385         c->flush_type = no_flush;
1386         return total_consumed;
1387 }
1388
1389 static size_t format_commit_item(struct strbuf *sb, /* in UTF-8 */
1390                                  const char *placeholder,
1391                                  void *context)
1392 {
1393         int consumed;
1394         size_t orig_len;
1395         enum {
1396                 NO_MAGIC,
1397                 ADD_LF_BEFORE_NON_EMPTY,
1398                 DEL_LF_BEFORE_EMPTY,
1399                 ADD_SP_BEFORE_NON_EMPTY
1400         } magic = NO_MAGIC;
1401
1402         switch (placeholder[0]) {
1403         case '-':
1404                 magic = DEL_LF_BEFORE_EMPTY;
1405                 break;
1406         case '+':
1407                 magic = ADD_LF_BEFORE_NON_EMPTY;
1408                 break;
1409         case ' ':
1410                 magic = ADD_SP_BEFORE_NON_EMPTY;
1411                 break;
1412         default:
1413                 break;
1414         }
1415         if (magic != NO_MAGIC)
1416                 placeholder++;
1417
1418         orig_len = sb->len;
1419         if (((struct format_commit_context *)context)->flush_type != no_flush)
1420                 consumed = format_and_pad_commit(sb, placeholder, context);
1421         else
1422                 consumed = format_commit_one(sb, placeholder, context);
1423         if (magic == NO_MAGIC)
1424                 return consumed;
1425
1426         if ((orig_len == sb->len) && magic == DEL_LF_BEFORE_EMPTY) {
1427                 while (sb->len && sb->buf[sb->len - 1] == '\n')
1428                         strbuf_setlen(sb, sb->len - 1);
1429         } else if (orig_len != sb->len) {
1430                 if (magic == ADD_LF_BEFORE_NON_EMPTY)
1431                         strbuf_insert(sb, orig_len, "\n", 1);
1432                 else if (magic == ADD_SP_BEFORE_NON_EMPTY)
1433                         strbuf_insert(sb, orig_len, " ", 1);
1434         }
1435         return consumed + 1;
1436 }
1437
1438 static size_t userformat_want_item(struct strbuf *sb, const char *placeholder,
1439                                    void *context)
1440 {
1441         struct userformat_want *w = context;
1442
1443         if (*placeholder == '+' || *placeholder == '-' || *placeholder == ' ')
1444                 placeholder++;
1445
1446         switch (*placeholder) {
1447         case 'N':
1448                 w->notes = 1;
1449                 break;
1450         }
1451         return 0;
1452 }
1453
1454 void userformat_find_requirements(const char *fmt, struct userformat_want *w)
1455 {
1456         struct strbuf dummy = STRBUF_INIT;
1457
1458         if (!fmt) {
1459                 if (!user_format)
1460                         return;
1461                 fmt = user_format;
1462         }
1463         strbuf_expand(&dummy, fmt, userformat_want_item, w);
1464         strbuf_release(&dummy);
1465 }
1466
1467 void format_commit_message(const struct commit *commit,
1468                            const char *format, struct strbuf *sb,
1469                            const struct pretty_print_context *pretty_ctx)
1470 {
1471         struct format_commit_context context;
1472         const char *output_enc = pretty_ctx->output_encoding;
1473         const char *utf8 = "UTF-8";
1474
1475         memset(&context, 0, sizeof(context));
1476         context.commit = commit;
1477         context.pretty_ctx = pretty_ctx;
1478         context.wrap_start = sb->len;
1479         /*
1480          * convert a commit message to UTF-8 first
1481          * as far as 'format_commit_item' assumes it in UTF-8
1482          */
1483         context.message = logmsg_reencode(commit,
1484                                           &context.commit_encoding,
1485                                           utf8);
1486
1487         strbuf_expand(sb, format, format_commit_item, &context);
1488         rewrap_message_tail(sb, &context, 0, 0, 0);
1489
1490         /* then convert a commit message to an actual output encoding */
1491         if (output_enc) {
1492                 if (same_encoding(utf8, output_enc))
1493                         output_enc = NULL;
1494         } else {
1495                 if (context.commit_encoding &&
1496                     !same_encoding(context.commit_encoding, utf8))
1497                         output_enc = context.commit_encoding;
1498         }
1499
1500         if (output_enc) {
1501                 int outsz;
1502                 char *out = reencode_string_len(sb->buf, sb->len,
1503                                                 output_enc, utf8, &outsz);
1504                 if (out)
1505                         strbuf_attach(sb, out, outsz, outsz + 1);
1506         }
1507
1508         free(context.commit_encoding);
1509         unuse_commit_buffer(commit, context.message);
1510 }
1511
1512 static void pp_header(struct pretty_print_context *pp,
1513                       const char *encoding,
1514                       const struct commit *commit,
1515                       const char **msg_p,
1516                       struct strbuf *sb)
1517 {
1518         int parents_shown = 0;
1519
1520         for (;;) {
1521                 const char *name, *line = *msg_p;
1522                 int linelen = get_one_line(*msg_p);
1523
1524                 if (!linelen)
1525                         return;
1526                 *msg_p += linelen;
1527
1528                 if (linelen == 1)
1529                         /* End of header */
1530                         return;
1531
1532                 if (pp->fmt == CMIT_FMT_RAW) {
1533                         strbuf_add(sb, line, linelen);
1534                         continue;
1535                 }
1536
1537                 if (starts_with(line, "parent ")) {
1538                         if (linelen != 48)
1539                                 die("bad parent line in commit");
1540                         continue;
1541                 }
1542
1543                 if (!parents_shown) {
1544                         unsigned num = commit_list_count(commit->parents);
1545                         /* with enough slop */
1546                         strbuf_grow(sb, num * 50 + 20);
1547                         add_merge_info(pp, sb, commit);
1548                         parents_shown = 1;
1549                 }
1550
1551                 /*
1552                  * MEDIUM == DEFAULT shows only author with dates.
1553                  * FULL shows both authors but not dates.
1554                  * FULLER shows both authors and dates.
1555                  */
1556                 if (skip_prefix(line, "author ", &name)) {
1557                         strbuf_grow(sb, linelen + 80);
1558                         pp_user_info(pp, "Author", sb, name, encoding);
1559                 }
1560                 if (skip_prefix(line, "committer ", &name) &&
1561                     (pp->fmt == CMIT_FMT_FULL || pp->fmt == CMIT_FMT_FULLER)) {
1562                         strbuf_grow(sb, linelen + 80);
1563                         pp_user_info(pp, "Commit", sb, name, encoding);
1564                 }
1565         }
1566 }
1567
1568 void pp_title_line(struct pretty_print_context *pp,
1569                    const char **msg_p,
1570                    struct strbuf *sb,
1571                    const char *encoding,
1572                    int need_8bit_cte)
1573 {
1574         static const int max_length = 78; /* per rfc2047 */
1575         struct strbuf title;
1576
1577         strbuf_init(&title, 80);
1578         *msg_p = format_subject(&title, *msg_p,
1579                                 pp->preserve_subject ? "\n" : " ");
1580
1581         strbuf_grow(sb, title.len + 1024);
1582         if (pp->subject) {
1583                 strbuf_addstr(sb, pp->subject);
1584                 if (needs_rfc2047_encoding(title.buf, title.len, RFC2047_SUBJECT))
1585                         add_rfc2047(sb, title.buf, title.len,
1586                                                 encoding, RFC2047_SUBJECT);
1587                 else
1588                         strbuf_add_wrapped_bytes(sb, title.buf, title.len,
1589                                          -last_line_length(sb), 1, max_length);
1590         } else {
1591                 strbuf_addbuf(sb, &title);
1592         }
1593         strbuf_addch(sb, '\n');
1594
1595         if (need_8bit_cte == 0) {
1596                 int i;
1597                 for (i = 0; i < pp->in_body_headers.nr; i++) {
1598                         if (has_non_ascii(pp->in_body_headers.items[i].string)) {
1599                                 need_8bit_cte = 1;
1600                                 break;
1601                         }
1602                 }
1603         }
1604
1605         if (need_8bit_cte > 0) {
1606                 const char *header_fmt =
1607                         "MIME-Version: 1.0\n"
1608                         "Content-Type: text/plain; charset=%s\n"
1609                         "Content-Transfer-Encoding: 8bit\n";
1610                 strbuf_addf(sb, header_fmt, encoding);
1611         }
1612         if (pp->after_subject) {
1613                 strbuf_addstr(sb, pp->after_subject);
1614         }
1615         if (pp->fmt == CMIT_FMT_EMAIL) {
1616                 strbuf_addch(sb, '\n');
1617         }
1618
1619         if (pp->in_body_headers.nr) {
1620                 int i;
1621                 for (i = 0; i < pp->in_body_headers.nr; i++) {
1622                         strbuf_addstr(sb, pp->in_body_headers.items[i].string);
1623                         free(pp->in_body_headers.items[i].string);
1624                 }
1625                 string_list_clear(&pp->in_body_headers, 0);
1626                 strbuf_addch(sb, '\n');
1627         }
1628
1629         strbuf_release(&title);
1630 }
1631
1632 void pp_remainder(struct pretty_print_context *pp,
1633                   const char **msg_p,
1634                   struct strbuf *sb,
1635                   int indent)
1636 {
1637         int first = 1;
1638         for (;;) {
1639                 const char *line = *msg_p;
1640                 int linelen = get_one_line(line);
1641                 *msg_p += linelen;
1642
1643                 if (!linelen)
1644                         break;
1645
1646                 if (is_empty_line(line, &linelen)) {
1647                         if (first)
1648                                 continue;
1649                         if (pp->fmt == CMIT_FMT_SHORT)
1650                                 break;
1651                 }
1652                 first = 0;
1653
1654                 strbuf_grow(sb, linelen + indent + 20);
1655                 if (indent)
1656                         strbuf_addchars(sb, ' ', indent);
1657                 strbuf_add(sb, line, linelen);
1658                 strbuf_addch(sb, '\n');
1659         }
1660 }
1661
1662 void pretty_print_commit(struct pretty_print_context *pp,
1663                          const struct commit *commit,
1664                          struct strbuf *sb)
1665 {
1666         unsigned long beginning_of_body;
1667         int indent = 4;
1668         const char *msg;
1669         const char *reencoded;
1670         const char *encoding;
1671         int need_8bit_cte = pp->need_8bit_cte;
1672
1673         if (pp->fmt == CMIT_FMT_USERFORMAT) {
1674                 format_commit_message(commit, user_format, sb, pp);
1675                 return;
1676         }
1677
1678         encoding = get_log_output_encoding();
1679         msg = reencoded = logmsg_reencode(commit, NULL, encoding);
1680
1681         if (pp->fmt == CMIT_FMT_ONELINE || pp->fmt == CMIT_FMT_EMAIL)
1682                 indent = 0;
1683
1684         /*
1685          * We need to check and emit Content-type: to mark it
1686          * as 8-bit if we haven't done so.
1687          */
1688         if (pp->fmt == CMIT_FMT_EMAIL && need_8bit_cte == 0) {
1689                 int i, ch, in_body;
1690
1691                 for (in_body = i = 0; (ch = msg[i]); i++) {
1692                         if (!in_body) {
1693                                 /* author could be non 7-bit ASCII but
1694                                  * the log may be so; skip over the
1695                                  * header part first.
1696                                  */
1697                                 if (ch == '\n' && msg[i+1] == '\n')
1698                                         in_body = 1;
1699                         }
1700                         else if (non_ascii(ch)) {
1701                                 need_8bit_cte = 1;
1702                                 break;
1703                         }
1704                 }
1705         }
1706
1707         pp_header(pp, encoding, commit, &msg, sb);
1708         if (pp->fmt != CMIT_FMT_ONELINE && !pp->subject) {
1709                 strbuf_addch(sb, '\n');
1710         }
1711
1712         /* Skip excess blank lines at the beginning of body, if any... */
1713         msg = skip_empty_lines(msg);
1714
1715         /* These formats treat the title line specially. */
1716         if (pp->fmt == CMIT_FMT_ONELINE || pp->fmt == CMIT_FMT_EMAIL)
1717                 pp_title_line(pp, &msg, sb, encoding, need_8bit_cte);
1718
1719         beginning_of_body = sb->len;
1720         if (pp->fmt != CMIT_FMT_ONELINE)
1721                 pp_remainder(pp, &msg, sb, indent);
1722         strbuf_rtrim(sb);
1723
1724         /* Make sure there is an EOLN for the non-oneline case */
1725         if (pp->fmt != CMIT_FMT_ONELINE)
1726                 strbuf_addch(sb, '\n');
1727
1728         /*
1729          * The caller may append additional body text in e-mail
1730          * format.  Make sure we did not strip the blank line
1731          * between the header and the body.
1732          */
1733         if (pp->fmt == CMIT_FMT_EMAIL && sb->len <= beginning_of_body)
1734                 strbuf_addch(sb, '\n');
1735
1736         unuse_commit_buffer(commit, reencoded);
1737 }
1738
1739 void pp_commit_easy(enum cmit_fmt fmt, const struct commit *commit,
1740                     struct strbuf *sb)
1741 {
1742         struct pretty_print_context pp = {0};
1743         pp.fmt = fmt;
1744         pretty_print_commit(&pp, commit, sb);
1745 }