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