pretty.con commit t7810-grep.sh: fix duplicated test name (878452b)
   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
  14static char *user_format;
  15static 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;
  22static size_t builtin_formats_len;
  23static size_t commit_formats_len;
  24static size_t commit_formats_alloc;
  25static struct cmt_fmt_map *find_commit_format(const char *sought);
  26
  27int commit_format_is_empty(enum cmit_fmt fmt)
  28{
  29        return fmt == CMIT_FMT_USERFORMAT && !*user_format;
  30}
  31
  32static 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
  41static 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
  87static 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
 107static 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
 142static 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
 150void 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 */
 184static 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 */
 200static int non_ascii(int ch)
 201{
 202        return !isascii(ch) || ch == '\033';
 203}
 204
 205int 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
 217static 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
 239static 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
 248static 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
 259static 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
 280enum rfc2047_type {
 281        RFC2047_SUBJECT,
 282        RFC2047_ADDRESS
 283};
 284
 285static 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
 337static 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
 353static 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
 401const char *show_ident_date(const struct ident_split *ident,
 402                            enum 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
 420void 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_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
 508static 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
 517static 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
 531static 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
 556static 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
 563static 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
 594const 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
 662static 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
 673static size_t format_person_part(struct strbuf *sb, char part,
 674                                 const char *msg, int len, enum date_mode dmode)
 675{
 676        /* currently all placeholders have same length */
 677        const int placeholder_len = 2;
 678        struct ident_split s;
 679        const char *name, *mail;
 680        size_t maillen, namelen;
 681
 682        if (split_ident_line(&s, msg, len) < 0)
 683                goto skip;
 684
 685        name = s.name_begin;
 686        namelen = s.name_end - s.name_begin;
 687        mail = s.mail_begin;
 688        maillen = s.mail_end - s.mail_begin;
 689
 690        if (part == 'N' || part == 'E') /* mailmap lookup */
 691                mailmap_name(&mail, &maillen, &name, &namelen);
 692        if (part == 'n' || part == 'N') {       /* name */
 693                strbuf_add(sb, name, namelen);
 694                return placeholder_len;
 695        }
 696        if (part == 'e' || part == 'E') {       /* email */
 697                strbuf_add(sb, mail, maillen);
 698                return placeholder_len;
 699        }
 700
 701        if (!s.date_begin)
 702                goto skip;
 703
 704        if (part == 't') {      /* date, UNIX timestamp */
 705                strbuf_add(sb, s.date_begin, s.date_end - s.date_begin);
 706                return placeholder_len;
 707        }
 708
 709        switch (part) {
 710        case 'd':       /* date */
 711                strbuf_addstr(sb, show_ident_date(&s, dmode));
 712                return placeholder_len;
 713        case 'D':       /* date, RFC2822 style */
 714                strbuf_addstr(sb, show_ident_date(&s, DATE_RFC2822));
 715                return placeholder_len;
 716        case 'r':       /* date, relative */
 717                strbuf_addstr(sb, show_ident_date(&s, DATE_RELATIVE));
 718                return placeholder_len;
 719        case 'i':       /* date, ISO 8601-like */
 720                strbuf_addstr(sb, show_ident_date(&s, DATE_ISO8601));
 721                return placeholder_len;
 722        case 'I':       /* date, ISO 8601 strict */
 723                strbuf_addstr(sb, show_ident_date(&s, DATE_ISO8601_STRICT));
 724                return placeholder_len;
 725        }
 726
 727skip:
 728        /*
 729         * reading from either a bogus commit, or a reflog entry with
 730         * %gn, %ge, etc.; 'sb' cannot be updated, but we still need
 731         * to compute a valid return value.
 732         */
 733        if (part == 'n' || part == 'e' || part == 't' || part == 'd'
 734            || part == 'D' || part == 'r' || part == 'i')
 735                return placeholder_len;
 736
 737        return 0; /* unknown placeholder */
 738}
 739
 740struct chunk {
 741        size_t off;
 742        size_t len;
 743};
 744
 745enum flush_type {
 746        no_flush,
 747        flush_right,
 748        flush_left,
 749        flush_left_and_steal,
 750        flush_both
 751};
 752
 753enum trunc_type {
 754        trunc_none,
 755        trunc_left,
 756        trunc_middle,
 757        trunc_right
 758};
 759
 760struct format_commit_context {
 761        const struct commit *commit;
 762        const struct pretty_print_context *pretty_ctx;
 763        unsigned commit_header_parsed:1;
 764        unsigned commit_message_parsed:1;
 765        struct signature_check signature_check;
 766        enum flush_type flush_type;
 767        enum trunc_type truncate;
 768        const char *message;
 769        char *commit_encoding;
 770        size_t width, indent1, indent2;
 771        int auto_color;
 772        int padding;
 773
 774        /* These offsets are relative to the start of the commit message. */
 775        struct chunk author;
 776        struct chunk committer;
 777        size_t message_off;
 778        size_t subject_off;
 779        size_t body_off;
 780
 781        /* The following ones are relative to the result struct strbuf. */
 782        struct chunk abbrev_commit_hash;
 783        struct chunk abbrev_tree_hash;
 784        struct chunk abbrev_parent_hashes;
 785        size_t wrap_start;
 786};
 787
 788static int add_again(struct strbuf *sb, struct chunk *chunk)
 789{
 790        if (chunk->len) {
 791                strbuf_adddup(sb, chunk->off, chunk->len);
 792                return 1;
 793        }
 794
 795        /*
 796         * We haven't seen this chunk before.  Our caller is surely
 797         * going to add it the hard way now.  Remember the most likely
 798         * start of the to-be-added chunk: the current end of the
 799         * struct strbuf.
 800         */
 801        chunk->off = sb->len;
 802        return 0;
 803}
 804
 805static void parse_commit_header(struct format_commit_context *context)
 806{
 807        const char *msg = context->message;
 808        int i;
 809
 810        for (i = 0; msg[i]; i++) {
 811                const char *name;
 812                int eol;
 813                for (eol = i; msg[eol] && msg[eol] != '\n'; eol++)
 814                        ; /* do nothing */
 815
 816                if (i == eol) {
 817                        break;
 818                } else if (skip_prefix(msg + i, "author ", &name)) {
 819                        context->author.off = name - msg;
 820                        context->author.len = msg + eol - name;
 821                } else if (skip_prefix(msg + i, "committer ", &name)) {
 822                        context->committer.off = name - msg;
 823                        context->committer.len = msg + eol - name;
 824                }
 825                i = eol;
 826        }
 827        context->message_off = i;
 828        context->commit_header_parsed = 1;
 829}
 830
 831static int istitlechar(char c)
 832{
 833        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
 834                (c >= '0' && c <= '9') || c == '.' || c == '_';
 835}
 836
 837static void format_sanitized_subject(struct strbuf *sb, const char *msg)
 838{
 839        size_t trimlen;
 840        size_t start_len = sb->len;
 841        int space = 2;
 842
 843        for (; *msg && *msg != '\n'; msg++) {
 844                if (istitlechar(*msg)) {
 845                        if (space == 1)
 846                                strbuf_addch(sb, '-');
 847                        space = 0;
 848                        strbuf_addch(sb, *msg);
 849                        if (*msg == '.')
 850                                while (*(msg+1) == '.')
 851                                        msg++;
 852                } else
 853                        space |= 1;
 854        }
 855
 856        /* trim any trailing '.' or '-' characters */
 857        trimlen = 0;
 858        while (sb->len - trimlen > start_len &&
 859                (sb->buf[sb->len - 1 - trimlen] == '.'
 860                || sb->buf[sb->len - 1 - trimlen] == '-'))
 861                trimlen++;
 862        strbuf_remove(sb, sb->len - trimlen, trimlen);
 863}
 864
 865const char *format_subject(struct strbuf *sb, const char *msg,
 866                           const char *line_separator)
 867{
 868        int first = 1;
 869
 870        for (;;) {
 871                const char *line = msg;
 872                int linelen = get_one_line(line);
 873
 874                msg += linelen;
 875                if (!linelen || is_empty_line(line, &linelen))
 876                        break;
 877
 878                if (!sb)
 879                        continue;
 880                strbuf_grow(sb, linelen + 2);
 881                if (!first)
 882                        strbuf_addstr(sb, line_separator);
 883                strbuf_add(sb, line, linelen);
 884                first = 0;
 885        }
 886        return msg;
 887}
 888
 889static void parse_commit_message(struct format_commit_context *c)
 890{
 891        const char *msg = c->message + c->message_off;
 892        const char *start = c->message;
 893
 894        msg = skip_empty_lines(msg);
 895        c->subject_off = msg - start;
 896
 897        msg = format_subject(NULL, msg, NULL);
 898        msg = skip_empty_lines(msg);
 899        c->body_off = msg - start;
 900
 901        c->commit_message_parsed = 1;
 902}
 903
 904static void strbuf_wrap(struct strbuf *sb, size_t pos,
 905                        size_t width, size_t indent1, size_t indent2)
 906{
 907        struct strbuf tmp = STRBUF_INIT;
 908
 909        if (pos)
 910                strbuf_add(&tmp, sb->buf, pos);
 911        strbuf_add_wrapped_text(&tmp, sb->buf + pos,
 912                                (int) indent1, (int) indent2, (int) width);
 913        strbuf_swap(&tmp, sb);
 914        strbuf_release(&tmp);
 915}
 916
 917static void rewrap_message_tail(struct strbuf *sb,
 918                                struct format_commit_context *c,
 919                                size_t new_width, size_t new_indent1,
 920                                size_t new_indent2)
 921{
 922        if (c->width == new_width && c->indent1 == new_indent1 &&
 923            c->indent2 == new_indent2)
 924                return;
 925        if (c->wrap_start < sb->len)
 926                strbuf_wrap(sb, c->wrap_start, c->width, c->indent1, c->indent2);
 927        c->wrap_start = sb->len;
 928        c->width = new_width;
 929        c->indent1 = new_indent1;
 930        c->indent2 = new_indent2;
 931}
 932
 933static int format_reflog_person(struct strbuf *sb,
 934                                char part,
 935                                struct reflog_walk_info *log,
 936                                enum date_mode dmode)
 937{
 938        const char *ident;
 939
 940        if (!log)
 941                return 2;
 942
 943        ident = get_reflog_ident(log);
 944        if (!ident)
 945                return 2;
 946
 947        return format_person_part(sb, part, ident, strlen(ident), dmode);
 948}
 949
 950static size_t parse_color(struct strbuf *sb, /* in UTF-8 */
 951                          const char *placeholder,
 952                          struct format_commit_context *c)
 953{
 954        const char *rest = placeholder;
 955
 956        if (placeholder[1] == '(') {
 957                const char *begin = placeholder + 2;
 958                const char *end = strchr(begin, ')');
 959                char color[COLOR_MAXLEN];
 960
 961                if (!end)
 962                        return 0;
 963                if (skip_prefix(begin, "auto,", &begin)) {
 964                        if (!want_color(c->pretty_ctx->color))
 965                                return end - placeholder + 1;
 966                }
 967                if (color_parse_mem(begin, end - begin, color) < 0)
 968                        die(_("unable to parse --pretty format"));
 969                strbuf_addstr(sb, color);
 970                return end - placeholder + 1;
 971        }
 972        if (skip_prefix(placeholder + 1, "red", &rest))
 973                strbuf_addstr(sb, GIT_COLOR_RED);
 974        else if (skip_prefix(placeholder + 1, "green", &rest))
 975                strbuf_addstr(sb, GIT_COLOR_GREEN);
 976        else if (skip_prefix(placeholder + 1, "blue", &rest))
 977                strbuf_addstr(sb, GIT_COLOR_BLUE);
 978        else if (skip_prefix(placeholder + 1, "reset", &rest))
 979                strbuf_addstr(sb, GIT_COLOR_RESET);
 980        return rest - placeholder;
 981}
 982
 983static size_t parse_padding_placeholder(struct strbuf *sb,
 984                                        const char *placeholder,
 985                                        struct format_commit_context *c)
 986{
 987        const char *ch = placeholder;
 988        enum flush_type flush_type;
 989        int to_column = 0;
 990
 991        switch (*ch++) {
 992        case '<':
 993                flush_type = flush_right;
 994                break;
 995        case '>':
 996                if (*ch == '<') {
 997                        flush_type = flush_both;
 998                        ch++;
 999                } else if (*ch == '>') {
1000                        flush_type = flush_left_and_steal;
1001                        ch++;
1002                } else
1003                        flush_type = flush_left;
1004                break;
1005        default:
1006                return 0;
1007        }
1008
1009        /* the next value means "wide enough to that column" */
1010        if (*ch == '|') {
1011                to_column = 1;
1012                ch++;
1013        }
1014
1015        if (*ch == '(') {
1016                const char *start = ch + 1;
1017                const char *end = start + strcspn(start, ",)");
1018                char *next;
1019                int width;
1020                if (!end || end == start)
1021                        return 0;
1022                width = strtoul(start, &next, 10);
1023                if (next == start || width == 0)
1024                        return 0;
1025                c->padding = to_column ? -width : width;
1026                c->flush_type = flush_type;
1027
1028                if (*end == ',') {
1029                        start = end + 1;
1030                        end = strchr(start, ')');
1031                        if (!end || end == start)
1032                                return 0;
1033                        if (starts_with(start, "trunc)"))
1034                                c->truncate = trunc_right;
1035                        else if (starts_with(start, "ltrunc)"))
1036                                c->truncate = trunc_left;
1037                        else if (starts_with(start, "mtrunc)"))
1038                                c->truncate = trunc_middle;
1039                        else
1040                                return 0;
1041                } else
1042                        c->truncate = trunc_none;
1043
1044                return end - placeholder + 1;
1045        }
1046        return 0;
1047}
1048
1049static size_t format_commit_one(struct strbuf *sb, /* in UTF-8 */
1050                                const char *placeholder,
1051                                void *context)
1052{
1053        struct format_commit_context *c = context;
1054        const struct commit *commit = c->commit;
1055        const char *msg = c->message;
1056        struct commit_list *p;
1057        int h1, h2;
1058
1059        /* these are independent of the commit */
1060        switch (placeholder[0]) {
1061        case 'C':
1062                if (starts_with(placeholder + 1, "(auto)")) {
1063                        c->auto_color = 1;
1064                        return 7; /* consumed 7 bytes, "C(auto)" */
1065                } else {
1066                        int ret = parse_color(sb, placeholder, c);
1067                        if (ret)
1068                                c->auto_color = 0;
1069                        /*
1070                         * Otherwise, we decided to treat %C<unknown>
1071                         * as a literal string, and the previous
1072                         * %C(auto) is still valid.
1073                         */
1074                        return ret;
1075                }
1076        case 'n':               /* newline */
1077                strbuf_addch(sb, '\n');
1078                return 1;
1079        case 'x':
1080                /* %x00 == NUL, %x0a == LF, etc. */
1081                if (0 <= (h1 = hexval_table[0xff & placeholder[1]]) &&
1082                    h1 <= 16 &&
1083                    0 <= (h2 = hexval_table[0xff & placeholder[2]]) &&
1084                    h2 <= 16) {
1085                        strbuf_addch(sb, (h1<<4)|h2);
1086                        return 3;
1087                } else
1088                        return 0;
1089        case 'w':
1090                if (placeholder[1] == '(') {
1091                        unsigned long width = 0, indent1 = 0, indent2 = 0;
1092                        char *next;
1093                        const char *start = placeholder + 2;
1094                        const char *end = strchr(start, ')');
1095                        if (!end)
1096                                return 0;
1097                        if (end > start) {
1098                                width = strtoul(start, &next, 10);
1099                                if (*next == ',') {
1100                                        indent1 = strtoul(next + 1, &next, 10);
1101                                        if (*next == ',') {
1102                                                indent2 = strtoul(next + 1,
1103                                                                 &next, 10);
1104                                        }
1105                                }
1106                                if (*next != ')')
1107                                        return 0;
1108                        }
1109                        rewrap_message_tail(sb, c, width, indent1, indent2);
1110                        return end - placeholder + 1;
1111                } else
1112                        return 0;
1113
1114        case '<':
1115        case '>':
1116                return parse_padding_placeholder(sb, placeholder, c);
1117        }
1118
1119        /* these depend on the commit */
1120        if (!commit->object.parsed)
1121                parse_object(commit->object.sha1);
1122
1123        switch (placeholder[0]) {
1124        case 'H':               /* commit hash */
1125                strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_COMMIT));
1126                strbuf_addstr(sb, sha1_to_hex(commit->object.sha1));
1127                strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
1128                return 1;
1129        case 'h':               /* abbreviated commit hash */
1130                strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_COMMIT));
1131                if (add_again(sb, &c->abbrev_commit_hash)) {
1132                        strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
1133                        return 1;
1134                }
1135                strbuf_addstr(sb, find_unique_abbrev(commit->object.sha1,
1136                                                     c->pretty_ctx->abbrev));
1137                strbuf_addstr(sb, diff_get_color(c->auto_color, DIFF_RESET));
1138                c->abbrev_commit_hash.len = sb->len - c->abbrev_commit_hash.off;
1139                return 1;
1140        case 'T':               /* tree hash */
1141                strbuf_addstr(sb, sha1_to_hex(commit->tree->object.sha1));
1142                return 1;
1143        case 't':               /* abbreviated tree hash */
1144                if (add_again(sb, &c->abbrev_tree_hash))
1145                        return 1;
1146                strbuf_addstr(sb, find_unique_abbrev(commit->tree->object.sha1,
1147                                                     c->pretty_ctx->abbrev));
1148                c->abbrev_tree_hash.len = sb->len - c->abbrev_tree_hash.off;
1149                return 1;
1150        case 'P':               /* parent hashes */
1151                for (p = commit->parents; p; p = p->next) {
1152                        if (p != commit->parents)
1153                                strbuf_addch(sb, ' ');
1154                        strbuf_addstr(sb, sha1_to_hex(p->item->object.sha1));
1155                }
1156                return 1;
1157        case 'p':               /* abbreviated parent hashes */
1158                if (add_again(sb, &c->abbrev_parent_hashes))
1159                        return 1;
1160                for (p = commit->parents; p; p = p->next) {
1161                        if (p != commit->parents)
1162                                strbuf_addch(sb, ' ');
1163                        strbuf_addstr(sb, find_unique_abbrev(
1164                                        p->item->object.sha1,
1165                                        c->pretty_ctx->abbrev));
1166                }
1167                c->abbrev_parent_hashes.len = sb->len -
1168                                              c->abbrev_parent_hashes.off;
1169                return 1;
1170        case 'm':               /* left/right/bottom */
1171                strbuf_addstr(sb, get_revision_mark(NULL, commit));
1172                return 1;
1173        case 'd':
1174                load_ref_decorations(DECORATE_SHORT_REFS);
1175                format_decorations(sb, commit, c->auto_color);
1176                return 1;
1177        case 'D':
1178                load_ref_decorations(DECORATE_SHORT_REFS);
1179                format_decorations_extended(sb, commit, c->auto_color, "", ", ", "");
1180                return 1;
1181        case 'g':               /* reflog info */
1182                switch(placeholder[1]) {
1183                case 'd':       /* reflog selector */
1184                case 'D':
1185                        if (c->pretty_ctx->reflog_info)
1186                                get_reflog_selector(sb,
1187                                                    c->pretty_ctx->reflog_info,
1188                                                    c->pretty_ctx->date_mode,
1189                                                    c->pretty_ctx->date_mode_explicit,
1190                                                    (placeholder[1] == 'd'));
1191                        return 2;
1192                case 's':       /* reflog message */
1193                        if (c->pretty_ctx->reflog_info)
1194                                get_reflog_message(sb, c->pretty_ctx->reflog_info);
1195                        return 2;
1196                case 'n':
1197                case 'N':
1198                case 'e':
1199                case 'E':
1200                        return format_reflog_person(sb,
1201                                                    placeholder[1],
1202                                                    c->pretty_ctx->reflog_info,
1203                                                    c->pretty_ctx->date_mode);
1204                }
1205                return 0;       /* unknown %g placeholder */
1206        case 'N':
1207                if (c->pretty_ctx->notes_message) {
1208                        strbuf_addstr(sb, c->pretty_ctx->notes_message);
1209                        return 1;
1210                }
1211                return 0;
1212        }
1213
1214        if (placeholder[0] == 'G') {
1215                if (!c->signature_check.result)
1216                        check_commit_signature(c->commit, &(c->signature_check));
1217                switch (placeholder[1]) {
1218                case 'G':
1219                        if (c->signature_check.gpg_output)
1220                                strbuf_addstr(sb, c->signature_check.gpg_output);
1221                        break;
1222                case '?':
1223                        switch (c->signature_check.result) {
1224                        case 'G':
1225                        case 'B':
1226                        case 'U':
1227                        case 'N':
1228                                strbuf_addch(sb, c->signature_check.result);
1229                        }
1230                        break;
1231                case 'S':
1232                        if (c->signature_check.signer)
1233                                strbuf_addstr(sb, c->signature_check.signer);
1234                        break;
1235                case 'K':
1236                        if (c->signature_check.key)
1237                                strbuf_addstr(sb, c->signature_check.key);
1238                        break;
1239                default:
1240                        return 0;
1241                }
1242                return 2;
1243        }
1244
1245
1246        /* For the rest we have to parse the commit header. */
1247        if (!c->commit_header_parsed)
1248                parse_commit_header(c);
1249
1250        switch (placeholder[0]) {
1251        case 'a':       /* author ... */
1252                return format_person_part(sb, placeholder[1],
1253                                   msg + c->author.off, c->author.len,
1254                                   c->pretty_ctx->date_mode);
1255        case 'c':       /* committer ... */
1256                return format_person_part(sb, placeholder[1],
1257                                   msg + c->committer.off, c->committer.len,
1258                                   c->pretty_ctx->date_mode);
1259        case 'e':       /* encoding */
1260                if (c->commit_encoding)
1261                        strbuf_addstr(sb, c->commit_encoding);
1262                return 1;
1263        case 'B':       /* raw body */
1264                /* message_off is always left at the initial newline */
1265                strbuf_addstr(sb, msg + c->message_off + 1);
1266                return 1;
1267        }
1268
1269        /* Now we need to parse the commit message. */
1270        if (!c->commit_message_parsed)
1271                parse_commit_message(c);
1272
1273        switch (placeholder[0]) {
1274        case 's':       /* subject */
1275                format_subject(sb, msg + c->subject_off, " ");
1276                return 1;
1277        case 'f':       /* sanitized subject */
1278                format_sanitized_subject(sb, msg + c->subject_off);
1279                return 1;
1280        case 'b':       /* body */
1281                strbuf_addstr(sb, msg + c->body_off);
1282                return 1;
1283        }
1284        return 0;       /* unknown placeholder */
1285}
1286
1287static size_t format_and_pad_commit(struct strbuf *sb, /* in UTF-8 */
1288                                    const char *placeholder,
1289                                    struct format_commit_context *c)
1290{
1291        struct strbuf local_sb = STRBUF_INIT;
1292        int total_consumed = 0, len, padding = c->padding;
1293        if (padding < 0) {
1294                const char *start = strrchr(sb->buf, '\n');
1295                int occupied;
1296                if (!start)
1297                        start = sb->buf;
1298                occupied = utf8_strnwidth(start, -1, 1);
1299                padding = (-padding) - occupied;
1300        }
1301        while (1) {
1302                int modifier = *placeholder == 'C';
1303                int consumed = format_commit_one(&local_sb, placeholder, c);
1304                total_consumed += consumed;
1305
1306                if (!modifier)
1307                        break;
1308
1309                placeholder += consumed;
1310                if (*placeholder != '%')
1311                        break;
1312                placeholder++;
1313                total_consumed++;
1314        }
1315        len = utf8_strnwidth(local_sb.buf, -1, 1);
1316
1317        if (c->flush_type == flush_left_and_steal) {
1318                const char *ch = sb->buf + sb->len - 1;
1319                while (len > padding && ch > sb->buf) {
1320                        const char *p;
1321                        if (*ch == ' ') {
1322                                ch--;
1323                                padding++;
1324                                continue;
1325                        }
1326                        /* check for trailing ansi sequences */
1327                        if (*ch != 'm')
1328                                break;
1329                        p = ch - 1;
1330                        while (ch - p < 10 && *p != '\033')
1331                                p--;
1332                        if (*p != '\033' ||
1333                            ch + 1 - p != display_mode_esc_sequence_len(p))
1334                                break;
1335                        /*
1336                         * got a good ansi sequence, put it back to
1337                         * local_sb as we're cutting sb
1338                         */
1339                        strbuf_insert(&local_sb, 0, p, ch + 1 - p);
1340                        ch = p - 1;
1341                }
1342                strbuf_setlen(sb, ch + 1 - sb->buf);
1343                c->flush_type = flush_left;
1344        }
1345
1346        if (len > padding) {
1347                switch (c->truncate) {
1348                case trunc_left:
1349                        strbuf_utf8_replace(&local_sb,
1350                                            0, len - (padding - 2),
1351                                            "..");
1352                        break;
1353                case trunc_middle:
1354                        strbuf_utf8_replace(&local_sb,
1355                                            padding / 2 - 1,
1356                                            len - (padding - 2),
1357                                            "..");
1358                        break;
1359                case trunc_right:
1360                        strbuf_utf8_replace(&local_sb,
1361                                            padding - 2, len - (padding - 2),
1362                                            "..");
1363                        break;
1364                case trunc_none:
1365                        break;
1366                }
1367                strbuf_addbuf(sb, &local_sb);
1368        } else {
1369                int sb_len = sb->len, offset = 0;
1370                if (c->flush_type == flush_left)
1371                        offset = padding - len;
1372                else if (c->flush_type == flush_both)
1373                        offset = (padding - len) / 2;
1374                /*
1375                 * we calculate padding in columns, now
1376                 * convert it back to chars
1377                 */
1378                padding = padding - len + local_sb.len;
1379                strbuf_addchars(sb, ' ', padding);
1380                memcpy(sb->buf + sb_len + offset, local_sb.buf,
1381                       local_sb.len);
1382        }
1383        strbuf_release(&local_sb);
1384        c->flush_type = no_flush;
1385        return total_consumed;
1386}
1387
1388static size_t format_commit_item(struct strbuf *sb, /* in UTF-8 */
1389                                 const char *placeholder,
1390                                 void *context)
1391{
1392        int consumed;
1393        size_t orig_len;
1394        enum {
1395                NO_MAGIC,
1396                ADD_LF_BEFORE_NON_EMPTY,
1397                DEL_LF_BEFORE_EMPTY,
1398                ADD_SP_BEFORE_NON_EMPTY
1399        } magic = NO_MAGIC;
1400
1401        switch (placeholder[0]) {
1402        case '-':
1403                magic = DEL_LF_BEFORE_EMPTY;
1404                break;
1405        case '+':
1406                magic = ADD_LF_BEFORE_NON_EMPTY;
1407                break;
1408        case ' ':
1409                magic = ADD_SP_BEFORE_NON_EMPTY;
1410                break;
1411        default:
1412                break;
1413        }
1414        if (magic != NO_MAGIC)
1415                placeholder++;
1416
1417        orig_len = sb->len;
1418        if (((struct format_commit_context *)context)->flush_type != no_flush)
1419                consumed = format_and_pad_commit(sb, placeholder, context);
1420        else
1421                consumed = format_commit_one(sb, placeholder, context);
1422        if (magic == NO_MAGIC)
1423                return consumed;
1424
1425        if ((orig_len == sb->len) && magic == DEL_LF_BEFORE_EMPTY) {
1426                while (sb->len && sb->buf[sb->len - 1] == '\n')
1427                        strbuf_setlen(sb, sb->len - 1);
1428        } else if (orig_len != sb->len) {
1429                if (magic == ADD_LF_BEFORE_NON_EMPTY)
1430                        strbuf_insert(sb, orig_len, "\n", 1);
1431                else if (magic == ADD_SP_BEFORE_NON_EMPTY)
1432                        strbuf_insert(sb, orig_len, " ", 1);
1433        }
1434        return consumed + 1;
1435}
1436
1437static size_t userformat_want_item(struct strbuf *sb, const char *placeholder,
1438                                   void *context)
1439{
1440        struct userformat_want *w = context;
1441
1442        if (*placeholder == '+' || *placeholder == '-' || *placeholder == ' ')
1443                placeholder++;
1444
1445        switch (*placeholder) {
1446        case 'N':
1447                w->notes = 1;
1448                break;
1449        }
1450        return 0;
1451}
1452
1453void userformat_find_requirements(const char *fmt, struct userformat_want *w)
1454{
1455        struct strbuf dummy = STRBUF_INIT;
1456
1457        if (!fmt) {
1458                if (!user_format)
1459                        return;
1460                fmt = user_format;
1461        }
1462        strbuf_expand(&dummy, fmt, userformat_want_item, w);
1463        strbuf_release(&dummy);
1464}
1465
1466void format_commit_message(const struct commit *commit,
1467                           const char *format, struct strbuf *sb,
1468                           const struct pretty_print_context *pretty_ctx)
1469{
1470        struct format_commit_context context;
1471        const char *output_enc = pretty_ctx->output_encoding;
1472        const char *utf8 = "UTF-8";
1473
1474        memset(&context, 0, sizeof(context));
1475        context.commit = commit;
1476        context.pretty_ctx = pretty_ctx;
1477        context.wrap_start = sb->len;
1478        /*
1479         * convert a commit message to UTF-8 first
1480         * as far as 'format_commit_item' assumes it in UTF-8
1481         */
1482        context.message = logmsg_reencode(commit,
1483                                          &context.commit_encoding,
1484                                          utf8);
1485
1486        strbuf_expand(sb, format, format_commit_item, &context);
1487        rewrap_message_tail(sb, &context, 0, 0, 0);
1488
1489        /* then convert a commit message to an actual output encoding */
1490        if (output_enc) {
1491                if (same_encoding(utf8, output_enc))
1492                        output_enc = NULL;
1493        } else {
1494                if (context.commit_encoding &&
1495                    !same_encoding(context.commit_encoding, utf8))
1496                        output_enc = context.commit_encoding;
1497        }
1498
1499        if (output_enc) {
1500                int outsz;
1501                char *out = reencode_string_len(sb->buf, sb->len,
1502                                                output_enc, utf8, &outsz);
1503                if (out)
1504                        strbuf_attach(sb, out, outsz, outsz + 1);
1505        }
1506
1507        free(context.commit_encoding);
1508        unuse_commit_buffer(commit, context.message);
1509}
1510
1511static void pp_header(struct pretty_print_context *pp,
1512                      const char *encoding,
1513                      const struct commit *commit,
1514                      const char **msg_p,
1515                      struct strbuf *sb)
1516{
1517        int parents_shown = 0;
1518
1519        for (;;) {
1520                const char *name, *line = *msg_p;
1521                int linelen = get_one_line(*msg_p);
1522
1523                if (!linelen)
1524                        return;
1525                *msg_p += linelen;
1526
1527                if (linelen == 1)
1528                        /* End of header */
1529                        return;
1530
1531                if (pp->fmt == CMIT_FMT_RAW) {
1532                        strbuf_add(sb, line, linelen);
1533                        continue;
1534                }
1535
1536                if (starts_with(line, "parent ")) {
1537                        if (linelen != 48)
1538                                die("bad parent line in commit");
1539                        continue;
1540                }
1541
1542                if (!parents_shown) {
1543                        unsigned num = commit_list_count(commit->parents);
1544                        /* with enough slop */
1545                        strbuf_grow(sb, num * 50 + 20);
1546                        add_merge_info(pp, sb, commit);
1547                        parents_shown = 1;
1548                }
1549
1550                /*
1551                 * MEDIUM == DEFAULT shows only author with dates.
1552                 * FULL shows both authors but not dates.
1553                 * FULLER shows both authors and dates.
1554                 */
1555                if (skip_prefix(line, "author ", &name)) {
1556                        strbuf_grow(sb, linelen + 80);
1557                        pp_user_info(pp, "Author", sb, name, encoding);
1558                }
1559                if (skip_prefix(line, "committer ", &name) &&
1560                    (pp->fmt == CMIT_FMT_FULL || pp->fmt == CMIT_FMT_FULLER)) {
1561                        strbuf_grow(sb, linelen + 80);
1562                        pp_user_info(pp, "Commit", sb, name, encoding);
1563                }
1564        }
1565}
1566
1567void pp_title_line(struct pretty_print_context *pp,
1568                   const char **msg_p,
1569                   struct strbuf *sb,
1570                   const char *encoding,
1571                   int need_8bit_cte)
1572{
1573        static const int max_length = 78; /* per rfc2047 */
1574        struct strbuf title;
1575
1576        strbuf_init(&title, 80);
1577        *msg_p = format_subject(&title, *msg_p,
1578                                pp->preserve_subject ? "\n" : " ");
1579
1580        strbuf_grow(sb, title.len + 1024);
1581        if (pp->subject) {
1582                strbuf_addstr(sb, pp->subject);
1583                if (needs_rfc2047_encoding(title.buf, title.len, RFC2047_SUBJECT))
1584                        add_rfc2047(sb, title.buf, title.len,
1585                                                encoding, RFC2047_SUBJECT);
1586                else
1587                        strbuf_add_wrapped_bytes(sb, title.buf, title.len,
1588                                         -last_line_length(sb), 1, max_length);
1589        } else {
1590                strbuf_addbuf(sb, &title);
1591        }
1592        strbuf_addch(sb, '\n');
1593
1594        if (need_8bit_cte == 0) {
1595                int i;
1596                for (i = 0; i < pp->in_body_headers.nr; i++) {
1597                        if (has_non_ascii(pp->in_body_headers.items[i].string)) {
1598                                need_8bit_cte = 1;
1599                                break;
1600                        }
1601                }
1602        }
1603
1604        if (need_8bit_cte > 0) {
1605                const char *header_fmt =
1606                        "MIME-Version: 1.0\n"
1607                        "Content-Type: text/plain; charset=%s\n"
1608                        "Content-Transfer-Encoding: 8bit\n";
1609                strbuf_addf(sb, header_fmt, encoding);
1610        }
1611        if (pp->after_subject) {
1612                strbuf_addstr(sb, pp->after_subject);
1613        }
1614        if (pp->fmt == CMIT_FMT_EMAIL) {
1615                strbuf_addch(sb, '\n');
1616        }
1617
1618        if (pp->in_body_headers.nr) {
1619                int i;
1620                for (i = 0; i < pp->in_body_headers.nr; i++) {
1621                        strbuf_addstr(sb, pp->in_body_headers.items[i].string);
1622                        free(pp->in_body_headers.items[i].string);
1623                }
1624                string_list_clear(&pp->in_body_headers, 0);
1625                strbuf_addch(sb, '\n');
1626        }
1627
1628        strbuf_release(&title);
1629}
1630
1631void pp_remainder(struct pretty_print_context *pp,
1632                  const char **msg_p,
1633                  struct strbuf *sb,
1634                  int indent)
1635{
1636        int first = 1;
1637        for (;;) {
1638                const char *line = *msg_p;
1639                int linelen = get_one_line(line);
1640                *msg_p += linelen;
1641
1642                if (!linelen)
1643                        break;
1644
1645                if (is_empty_line(line, &linelen)) {
1646                        if (first)
1647                                continue;
1648                        if (pp->fmt == CMIT_FMT_SHORT)
1649                                break;
1650                }
1651                first = 0;
1652
1653                strbuf_grow(sb, linelen + indent + 20);
1654                if (indent)
1655                        strbuf_addchars(sb, ' ', indent);
1656                strbuf_add(sb, line, linelen);
1657                strbuf_addch(sb, '\n');
1658        }
1659}
1660
1661void pretty_print_commit(struct pretty_print_context *pp,
1662                         const struct commit *commit,
1663                         struct strbuf *sb)
1664{
1665        unsigned long beginning_of_body;
1666        int indent = 4;
1667        const char *msg;
1668        const char *reencoded;
1669        const char *encoding;
1670        int need_8bit_cte = pp->need_8bit_cte;
1671
1672        if (pp->fmt == CMIT_FMT_USERFORMAT) {
1673                format_commit_message(commit, user_format, sb, pp);
1674                return;
1675        }
1676
1677        encoding = get_log_output_encoding();
1678        msg = reencoded = logmsg_reencode(commit, NULL, encoding);
1679
1680        if (pp->fmt == CMIT_FMT_ONELINE || pp->fmt == CMIT_FMT_EMAIL)
1681                indent = 0;
1682
1683        /*
1684         * We need to check and emit Content-type: to mark it
1685         * as 8-bit if we haven't done so.
1686         */
1687        if (pp->fmt == CMIT_FMT_EMAIL && need_8bit_cte == 0) {
1688                int i, ch, in_body;
1689
1690                for (in_body = i = 0; (ch = msg[i]); i++) {
1691                        if (!in_body) {
1692                                /* author could be non 7-bit ASCII but
1693                                 * the log may be so; skip over the
1694                                 * header part first.
1695                                 */
1696                                if (ch == '\n' && msg[i+1] == '\n')
1697                                        in_body = 1;
1698                        }
1699                        else if (non_ascii(ch)) {
1700                                need_8bit_cte = 1;
1701                                break;
1702                        }
1703                }
1704        }
1705
1706        pp_header(pp, encoding, commit, &msg, sb);
1707        if (pp->fmt != CMIT_FMT_ONELINE && !pp->subject) {
1708                strbuf_addch(sb, '\n');
1709        }
1710
1711        /* Skip excess blank lines at the beginning of body, if any... */
1712        msg = skip_empty_lines(msg);
1713
1714        /* These formats treat the title line specially. */
1715        if (pp->fmt == CMIT_FMT_ONELINE || pp->fmt == CMIT_FMT_EMAIL)
1716                pp_title_line(pp, &msg, sb, encoding, need_8bit_cte);
1717
1718        beginning_of_body = sb->len;
1719        if (pp->fmt != CMIT_FMT_ONELINE)
1720                pp_remainder(pp, &msg, sb, indent);
1721        strbuf_rtrim(sb);
1722
1723        /* Make sure there is an EOLN for the non-oneline case */
1724        if (pp->fmt != CMIT_FMT_ONELINE)
1725                strbuf_addch(sb, '\n');
1726
1727        /*
1728         * The caller may append additional body text in e-mail
1729         * format.  Make sure we did not strip the blank line
1730         * between the header and the body.
1731         */
1732        if (pp->fmt == CMIT_FMT_EMAIL && sb->len <= beginning_of_body)
1733                strbuf_addch(sb, '\n');
1734
1735        unuse_commit_buffer(commit, reencoded);
1736}
1737
1738void pp_commit_easy(enum cmit_fmt fmt, const struct commit *commit,
1739                    struct strbuf *sb)
1740{
1741        struct pretty_print_context pp = {0};
1742        pp.fmt = fmt;
1743        pretty_print_commit(&pp, commit, sb);
1744}