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