2007-11-04 19:15:06 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "utf8.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "revision.h"
|
2008-07-21 18:03:49 +00:00
|
|
|
#include "string-list.h"
|
2008-07-11 23:28:18 +00:00
|
|
|
#include "mailmap.h"
|
2008-09-04 21:40:03 +00:00
|
|
|
#include "log-tree.h"
|
2009-10-09 10:21:57 +00:00
|
|
|
#include "notes.h"
|
expand --pretty=format color options
Currently, the only colors available to --pretty=format
users are red, green, and blue. Rather than expand it with a
few new colors, this patch makes the usual config color
syntax available, including more colors, backgrounds, and
attributes.
Because colors are no longer bounded to a single word (e.g.,
%Cred), this uses a more advanced syntax that features a
beginning and end delimiter (but the old syntax still
works). So you can now do:
git log --pretty=tformat:'%C(yellow)%h%C(reset) %s'
to emulate --pretty=oneline, or even
git log --pretty=tformat:'%C(cyan magenta bold)%s%C(reset)'
if you want to relive the awesomeness of 4-color CGA.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-01-17 15:38:46 +00:00
|
|
|
#include "color.h"
|
2009-10-19 15:48:10 +00:00
|
|
|
#include "reflog-walk.h"
|
2011-10-22 04:06:02 +00:00
|
|
|
#include "gpg-interface.h"
|
2007-11-04 19:15:06 +00:00
|
|
|
|
|
|
|
static char *user_format;
|
2010-05-02 11:00:42 +00:00
|
|
|
static struct cmt_fmt_map {
|
|
|
|
const char *name;
|
|
|
|
enum cmit_fmt format;
|
|
|
|
int is_tformat;
|
2010-05-02 11:00:43 +00:00
|
|
|
int is_alias;
|
|
|
|
const char *user_format;
|
2010-05-02 11:00:42 +00:00
|
|
|
} *commit_formats;
|
2010-05-02 11:00:44 +00:00
|
|
|
static size_t builtin_formats_len;
|
2010-05-02 11:00:42 +00:00
|
|
|
static size_t commit_formats_len;
|
2010-05-02 11:00:44 +00:00
|
|
|
static size_t commit_formats_alloc;
|
2010-05-02 11:00:42 +00:00
|
|
|
static struct cmt_fmt_map *find_commit_format(const char *sought);
|
2007-11-04 19:15:06 +00:00
|
|
|
|
2009-02-24 09:59:15 +00:00
|
|
|
static void save_user_format(struct rev_info *rev, const char *cp, int is_tformat)
|
|
|
|
{
|
|
|
|
free(user_format);
|
|
|
|
user_format = xstrdup(cp);
|
|
|
|
if (is_tformat)
|
|
|
|
rev->use_terminator = 1;
|
|
|
|
rev->commit_format = CMIT_FMT_USERFORMAT;
|
|
|
|
}
|
|
|
|
|
2010-05-02 11:00:44 +00:00
|
|
|
static int git_pretty_formats_config(const char *var, const char *value, void *cb)
|
2007-11-04 19:15:06 +00:00
|
|
|
{
|
2010-05-02 11:00:44 +00:00
|
|
|
struct cmt_fmt_map *commit_format = NULL;
|
|
|
|
const char *name;
|
|
|
|
const char *fmt;
|
2007-11-04 19:15:06 +00:00
|
|
|
int i;
|
2010-05-02 11:00:44 +00:00
|
|
|
|
|
|
|
if (prefixcmp(var, "pretty."))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
name = var + strlen("pretty.");
|
|
|
|
for (i = 0; i < builtin_formats_len; i++) {
|
|
|
|
if (!strcmp(commit_formats[i].name, name))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = builtin_formats_len; i < commit_formats_len; i++) {
|
|
|
|
if (!strcmp(commit_formats[i].name, name)) {
|
|
|
|
commit_format = &commit_formats[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!commit_format) {
|
|
|
|
ALLOC_GROW(commit_formats, commit_formats_len+1,
|
|
|
|
commit_formats_alloc);
|
|
|
|
commit_format = &commit_formats[commit_formats_len];
|
2010-05-08 21:07:39 +00:00
|
|
|
memset(commit_format, 0, sizeof(*commit_format));
|
2010-05-02 11:00:44 +00:00
|
|
|
commit_formats_len++;
|
|
|
|
}
|
|
|
|
|
|
|
|
commit_format->name = xstrdup(name);
|
|
|
|
commit_format->format = CMIT_FMT_USERFORMAT;
|
|
|
|
git_config_string(&fmt, var, value);
|
|
|
|
if (!prefixcmp(fmt, "format:") || !prefixcmp(fmt, "tformat:")) {
|
|
|
|
commit_format->is_tformat = fmt[0] == 't';
|
|
|
|
fmt = strchr(fmt, ':') + 1;
|
|
|
|
} else if (strchr(fmt, '%'))
|
|
|
|
commit_format->is_tformat = 1;
|
|
|
|
else
|
|
|
|
commit_format->is_alias = 1;
|
|
|
|
commit_format->user_format = fmt;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-02 11:00:42 +00:00
|
|
|
static void setup_commit_formats(void)
|
2007-11-04 19:15:06 +00:00
|
|
|
{
|
2010-05-02 11:00:42 +00:00
|
|
|
struct cmt_fmt_map builtin_formats[] = {
|
|
|
|
{ "raw", CMIT_FMT_RAW, 0 },
|
|
|
|
{ "medium", CMIT_FMT_MEDIUM, 0 },
|
|
|
|
{ "short", CMIT_FMT_SHORT, 0 },
|
|
|
|
{ "email", CMIT_FMT_EMAIL, 0 },
|
|
|
|
{ "fuller", CMIT_FMT_FULLER, 0 },
|
|
|
|
{ "full", CMIT_FMT_FULL, 0 },
|
|
|
|
{ "oneline", CMIT_FMT_ONELINE, 1 }
|
2008-04-08 00:11:34 +00:00
|
|
|
};
|
2010-05-02 11:00:42 +00:00
|
|
|
commit_formats_len = ARRAY_SIZE(builtin_formats);
|
2010-05-02 11:00:44 +00:00
|
|
|
builtin_formats_len = commit_formats_len;
|
|
|
|
ALLOC_GROW(commit_formats, commit_formats_len, commit_formats_alloc);
|
2010-05-02 11:00:42 +00:00
|
|
|
memcpy(commit_formats, builtin_formats,
|
|
|
|
sizeof(*builtin_formats)*ARRAY_SIZE(builtin_formats));
|
2010-05-02 11:00:44 +00:00
|
|
|
|
|
|
|
git_config(git_pretty_formats_config, NULL);
|
2010-05-02 11:00:42 +00:00
|
|
|
}
|
|
|
|
|
2010-05-02 11:00:43 +00:00
|
|
|
static struct cmt_fmt_map *find_commit_format_recursive(const char *sought,
|
|
|
|
const char *original,
|
|
|
|
int num_redirections)
|
2010-05-02 11:00:42 +00:00
|
|
|
{
|
|
|
|
struct cmt_fmt_map *found = NULL;
|
|
|
|
size_t found_match_len = 0;
|
|
|
|
int i;
|
|
|
|
|
2010-05-02 11:00:43 +00:00
|
|
|
if (num_redirections >= commit_formats_len)
|
|
|
|
die("invalid --pretty format: "
|
|
|
|
"'%s' references an alias which points to itself",
|
|
|
|
original);
|
2010-05-02 11:00:42 +00:00
|
|
|
|
|
|
|
for (i = 0; i < commit_formats_len; i++) {
|
|
|
|
size_t match_len;
|
|
|
|
|
|
|
|
if (prefixcmp(commit_formats[i].name, sought))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
match_len = strlen(commit_formats[i].name);
|
|
|
|
if (found == NULL || found_match_len > match_len) {
|
|
|
|
found = &commit_formats[i];
|
|
|
|
found_match_len = match_len;
|
|
|
|
}
|
|
|
|
}
|
2010-05-02 11:00:43 +00:00
|
|
|
|
|
|
|
if (found && found->is_alias) {
|
|
|
|
found = find_commit_format_recursive(found->user_format,
|
|
|
|
original,
|
|
|
|
num_redirections+1);
|
|
|
|
}
|
|
|
|
|
2010-05-02 11:00:42 +00:00
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2010-05-02 11:00:43 +00:00
|
|
|
static struct cmt_fmt_map *find_commit_format(const char *sought)
|
|
|
|
{
|
|
|
|
if (!commit_formats)
|
|
|
|
setup_commit_formats();
|
|
|
|
|
|
|
|
return find_commit_format_recursive(sought, sought, 0);
|
|
|
|
}
|
|
|
|
|
2010-05-02 11:00:42 +00:00
|
|
|
void get_commit_format(const char *arg, struct rev_info *rev)
|
|
|
|
{
|
|
|
|
struct cmt_fmt_map *commit_format;
|
2007-11-04 19:15:06 +00:00
|
|
|
|
2008-04-08 00:11:34 +00:00
|
|
|
rev->use_terminator = 0;
|
|
|
|
if (!arg || !*arg) {
|
|
|
|
rev->commit_format = CMIT_FMT_DEFAULT;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!prefixcmp(arg, "format:") || !prefixcmp(arg, "tformat:")) {
|
2009-02-24 09:59:15 +00:00
|
|
|
save_user_format(rev, strchr(arg, ':') + 1, arg[0] == 't');
|
2008-04-08 00:11:34 +00:00
|
|
|
return;
|
2007-11-04 19:15:06 +00:00
|
|
|
}
|
2010-05-02 11:00:42 +00:00
|
|
|
|
2009-02-24 09:59:15 +00:00
|
|
|
if (strchr(arg, '%')) {
|
|
|
|
save_user_format(rev, arg, 1);
|
|
|
|
return;
|
|
|
|
}
|
2007-11-04 19:15:06 +00:00
|
|
|
|
2010-05-02 11:00:42 +00:00
|
|
|
commit_format = find_commit_format(arg);
|
|
|
|
if (!commit_format)
|
|
|
|
die("invalid --pretty format: %s", arg);
|
|
|
|
|
|
|
|
rev->commit_format = commit_format->format;
|
|
|
|
rev->use_terminator = commit_format->is_tformat;
|
2010-05-02 11:00:44 +00:00
|
|
|
if (commit_format->format == CMIT_FMT_USERFORMAT) {
|
|
|
|
save_user_format(rev, commit_format->user_format,
|
|
|
|
commit_format->is_tformat);
|
|
|
|
}
|
2007-11-04 19:15:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Generic support for pretty-printing the header
|
|
|
|
*/
|
|
|
|
static int get_one_line(const char *msg)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
char c = *msg++;
|
|
|
|
if (!c)
|
|
|
|
break;
|
|
|
|
ret++;
|
|
|
|
if (c == '\n')
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* High bit set, or ISO-2022-INT */
|
2010-01-12 06:23:35 +00:00
|
|
|
static int non_ascii(int ch)
|
2007-11-04 19:15:06 +00:00
|
|
|
{
|
2009-03-07 13:06:49 +00:00
|
|
|
return !isascii(ch) || ch == '\033';
|
2007-11-04 19:15:06 +00:00
|
|
|
}
|
|
|
|
|
2009-08-10 16:22:18 +00:00
|
|
|
int has_non_ascii(const char *s)
|
|
|
|
{
|
|
|
|
int ch;
|
|
|
|
if (!s)
|
|
|
|
return 0;
|
|
|
|
while ((ch = *s++) != '\0') {
|
|
|
|
if (non_ascii(ch))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-08 22:40:36 +00:00
|
|
|
static int is_rfc822_special(char ch)
|
|
|
|
{
|
|
|
|
switch (ch) {
|
|
|
|
case '(':
|
|
|
|
case ')':
|
|
|
|
case '<':
|
|
|
|
case '>':
|
|
|
|
case '[':
|
|
|
|
case ']':
|
|
|
|
case ':':
|
|
|
|
case ';':
|
|
|
|
case '@':
|
|
|
|
case ',':
|
|
|
|
case '.':
|
|
|
|
case '"':
|
|
|
|
case '\\':
|
|
|
|
return 1;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int has_rfc822_specials(const char *s, int len)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
if (is_rfc822_special(s[i]))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_rfc822_quoted(struct strbuf *out, const char *s, int len)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* just a guess, we may have to also backslash-quote */
|
|
|
|
strbuf_grow(out, len + 2);
|
|
|
|
|
|
|
|
strbuf_addch(out, '"');
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
switch (s[i]) {
|
|
|
|
case '"':
|
|
|
|
case '\\':
|
|
|
|
strbuf_addch(out, '\\');
|
|
|
|
/* fall through */
|
|
|
|
default:
|
|
|
|
strbuf_addch(out, s[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
strbuf_addch(out, '"');
|
|
|
|
}
|
|
|
|
|
2007-11-04 19:15:06 +00:00
|
|
|
static int is_rfc2047_special(char ch)
|
|
|
|
{
|
|
|
|
return (non_ascii(ch) || (ch == '=') || (ch == '?') || (ch == '_'));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_rfc2047(struct strbuf *sb, const char *line, int len,
|
|
|
|
const char *encoding)
|
|
|
|
{
|
2011-02-23 09:58:41 +00:00
|
|
|
static const int max_length = 78; /* per rfc2822 */
|
|
|
|
int i;
|
|
|
|
int line_len;
|
|
|
|
|
|
|
|
/* How many bytes are already used on the current line? */
|
|
|
|
for (i = sb->len - 1; i >= 0; i--)
|
|
|
|
if (sb->buf[i] == '\n')
|
|
|
|
break;
|
|
|
|
line_len = sb->len - (i+1);
|
2007-11-04 19:15:06 +00:00
|
|
|
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
int ch = line[i];
|
2011-02-23 09:59:18 +00:00
|
|
|
if (non_ascii(ch) || ch == '\n')
|
2007-11-04 19:15:06 +00:00
|
|
|
goto needquote;
|
|
|
|
if ((i + 1 < len) && (ch == '=' && line[i+1] == '?'))
|
|
|
|
goto needquote;
|
|
|
|
}
|
2011-02-23 09:58:41 +00:00
|
|
|
strbuf_add_wrapped_bytes(sb, line, len, 0, 1, max_length - line_len);
|
2007-11-04 19:15:06 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
needquote:
|
|
|
|
strbuf_grow(sb, len * 3 + strlen(encoding) + 100);
|
|
|
|
strbuf_addf(sb, "=?%s?q?", encoding);
|
2011-02-23 09:58:41 +00:00
|
|
|
line_len += strlen(encoding) + 5; /* 5 for =??q? */
|
|
|
|
for (i = 0; i < len; i++) {
|
2007-11-04 19:15:06 +00:00
|
|
|
unsigned ch = line[i] & 0xFF;
|
2011-02-23 09:58:41 +00:00
|
|
|
|
|
|
|
if (line_len >= max_length - 2) {
|
|
|
|
strbuf_addf(sb, "?=\n =?%s?q?", encoding);
|
|
|
|
line_len = strlen(encoding) + 5 + 1; /* =??q? plus SP */
|
|
|
|
}
|
|
|
|
|
2007-11-04 19:15:06 +00:00
|
|
|
/*
|
|
|
|
* We encode ' ' using '=20' even though rfc2047
|
|
|
|
* allows using '_' for readability. Unfortunately,
|
|
|
|
* many programs do not understand this and just
|
|
|
|
* leave the underscore in place.
|
|
|
|
*/
|
2011-02-23 09:59:18 +00:00
|
|
|
if (is_rfc2047_special(ch) || ch == ' ' || ch == '\n') {
|
2007-11-04 19:15:06 +00:00
|
|
|
strbuf_addf(sb, "=%02X", ch);
|
2011-02-23 09:58:41 +00:00
|
|
|
line_len += 3;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
strbuf_addch(sb, ch);
|
|
|
|
line_len++;
|
2007-11-04 19:15:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
strbuf_addstr(sb, "?=");
|
|
|
|
}
|
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
void pp_user_info(const struct pretty_print_context *pp,
|
|
|
|
const char *what, struct strbuf *sb,
|
|
|
|
const char *line, const char *encoding)
|
2007-11-04 19:15:06 +00:00
|
|
|
{
|
|
|
|
char *date;
|
|
|
|
int namelen;
|
|
|
|
unsigned long time;
|
|
|
|
int tz;
|
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->fmt == CMIT_FMT_ONELINE)
|
2007-11-04 19:15:06 +00:00
|
|
|
return;
|
|
|
|
date = strchr(line, '>');
|
|
|
|
if (!date)
|
|
|
|
return;
|
|
|
|
namelen = ++date - line;
|
|
|
|
time = strtoul(date, &date, 10);
|
|
|
|
tz = strtol(date, NULL, 10);
|
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->fmt == CMIT_FMT_EMAIL) {
|
2007-11-04 19:15:06 +00:00
|
|
|
char *name_tail = strchr(line, '<');
|
|
|
|
int display_name_length;
|
2011-04-14 22:18:09 +00:00
|
|
|
int final_line;
|
2007-11-04 19:15:06 +00:00
|
|
|
if (!name_tail)
|
|
|
|
return;
|
|
|
|
while (line < name_tail && isspace(name_tail[-1]))
|
|
|
|
name_tail--;
|
|
|
|
display_name_length = name_tail - line;
|
|
|
|
strbuf_addstr(sb, "From: ");
|
2011-04-08 22:40:36 +00:00
|
|
|
if (!has_rfc822_specials(line, display_name_length)) {
|
|
|
|
add_rfc2047(sb, line, display_name_length, encoding);
|
|
|
|
} else {
|
|
|
|
struct strbuf quoted = STRBUF_INIT;
|
|
|
|
add_rfc822_quoted("ed, line, display_name_length);
|
|
|
|
add_rfc2047(sb, quoted.buf, quoted.len, encoding);
|
|
|
|
strbuf_release("ed);
|
|
|
|
}
|
2011-04-14 22:18:09 +00:00
|
|
|
for (final_line = 0; final_line < sb->len; final_line++)
|
|
|
|
if (sb->buf[sb->len - final_line - 1] == '\n')
|
|
|
|
break;
|
|
|
|
if (namelen - display_name_length + final_line > 78) {
|
|
|
|
strbuf_addch(sb, '\n');
|
|
|
|
if (!isspace(name_tail[0]))
|
|
|
|
strbuf_addch(sb, ' ');
|
|
|
|
}
|
2007-11-04 19:15:06 +00:00
|
|
|
strbuf_add(sb, name_tail, namelen - display_name_length);
|
|
|
|
strbuf_addch(sb, '\n');
|
|
|
|
} else {
|
|
|
|
strbuf_addf(sb, "%s: %.*s%.*s\n", what,
|
2011-05-26 22:27:49 +00:00
|
|
|
(pp->fmt == CMIT_FMT_FULLER) ? 4 : 0,
|
2009-03-13 12:51:33 +00:00
|
|
|
" ", namelen, line);
|
2007-11-04 19:15:06 +00:00
|
|
|
}
|
2011-05-26 22:27:49 +00:00
|
|
|
switch (pp->fmt) {
|
2007-11-04 19:15:06 +00:00
|
|
|
case CMIT_FMT_MEDIUM:
|
2011-05-26 22:27:49 +00:00
|
|
|
strbuf_addf(sb, "Date: %s\n", show_date(time, tz, pp->date_mode));
|
2007-11-04 19:15:06 +00:00
|
|
|
break;
|
|
|
|
case CMIT_FMT_EMAIL:
|
|
|
|
strbuf_addf(sb, "Date: %s\n", show_date(time, tz, DATE_RFC2822));
|
|
|
|
break;
|
|
|
|
case CMIT_FMT_FULLER:
|
2011-05-26 22:27:49 +00:00
|
|
|
strbuf_addf(sb, "%sDate: %s\n", what, show_date(time, tz, pp->date_mode));
|
2007-11-04 19:15:06 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* notin' */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int is_empty_line(const char *line, int *len_p)
|
|
|
|
{
|
|
|
|
int len = *len_p;
|
|
|
|
while (len && isspace(line[len-1]))
|
|
|
|
len--;
|
|
|
|
*len_p = len;
|
|
|
|
return !len;
|
|
|
|
}
|
|
|
|
|
2008-12-27 00:32:49 +00:00
|
|
|
static const char *skip_empty_lines(const char *msg)
|
|
|
|
{
|
|
|
|
for (;;) {
|
|
|
|
int linelen = get_one_line(msg);
|
|
|
|
int ll = linelen;
|
|
|
|
if (!linelen)
|
|
|
|
break;
|
|
|
|
if (!is_empty_line(msg, &ll))
|
|
|
|
break;
|
|
|
|
msg += linelen;
|
|
|
|
}
|
|
|
|
return msg;
|
|
|
|
}
|
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
static void add_merge_info(const struct pretty_print_context *pp,
|
|
|
|
struct strbuf *sb, const struct commit *commit)
|
2007-11-04 19:15:06 +00:00
|
|
|
{
|
|
|
|
struct commit_list *parent = commit->parents;
|
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
if ((pp->fmt == CMIT_FMT_ONELINE) || (pp->fmt == CMIT_FMT_EMAIL) ||
|
2007-11-04 19:15:06 +00:00
|
|
|
!parent || !parent->next)
|
|
|
|
return;
|
|
|
|
|
|
|
|
strbuf_addstr(sb, "Merge:");
|
|
|
|
|
|
|
|
while (parent) {
|
|
|
|
struct commit *p = parent->item;
|
|
|
|
const char *hex = NULL;
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->abbrev)
|
|
|
|
hex = find_unique_abbrev(p->object.sha1, pp->abbrev);
|
2007-11-04 19:15:06 +00:00
|
|
|
if (!hex)
|
|
|
|
hex = sha1_to_hex(p->object.sha1);
|
|
|
|
parent = parent->next;
|
|
|
|
|
2009-02-13 22:10:41 +00:00
|
|
|
strbuf_addf(sb, " %s", hex);
|
2007-11-04 19:15:06 +00:00
|
|
|
}
|
|
|
|
strbuf_addch(sb, '\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *get_header(const struct commit *commit, const char *key)
|
|
|
|
{
|
|
|
|
int key_len = strlen(key);
|
|
|
|
const char *line = commit->buffer;
|
|
|
|
|
2012-05-22 04:52:17 +00:00
|
|
|
while (line) {
|
2007-11-04 19:15:06 +00:00
|
|
|
const char *eol = strchr(line, '\n'), *next;
|
|
|
|
|
|
|
|
if (line == eol)
|
|
|
|
return NULL;
|
|
|
|
if (!eol) {
|
2012-05-22 04:52:17 +00:00
|
|
|
warning("malformed commit (header is missing newline): %s",
|
|
|
|
sha1_to_hex(commit->object.sha1));
|
2007-11-04 19:15:06 +00:00
|
|
|
eol = line + strlen(line);
|
|
|
|
next = NULL;
|
|
|
|
} else
|
|
|
|
next = eol + 1;
|
|
|
|
if (eol - line > key_len &&
|
|
|
|
!strncmp(line, key, key_len) &&
|
|
|
|
line[key_len] == ' ') {
|
|
|
|
return xmemdupz(line + key_len + 1, eol - line - key_len - 1);
|
|
|
|
}
|
|
|
|
line = next;
|
|
|
|
}
|
2012-05-22 04:52:17 +00:00
|
|
|
return NULL;
|
2007-11-04 19:15:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static char *replace_encoding_header(char *buf, const char *encoding)
|
|
|
|
{
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf tmp = STRBUF_INIT;
|
2007-11-04 19:15:06 +00:00
|
|
|
size_t start, len;
|
|
|
|
char *cp = buf;
|
|
|
|
|
|
|
|
/* guess if there is an encoding header before a \n\n */
|
|
|
|
while (strncmp(cp, "encoding ", strlen("encoding "))) {
|
|
|
|
cp = strchr(cp, '\n');
|
|
|
|
if (!cp || *++cp == '\n')
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
start = cp - buf;
|
|
|
|
cp = strchr(cp, '\n');
|
|
|
|
if (!cp)
|
|
|
|
return buf; /* should not happen but be defensive */
|
|
|
|
len = cp + 1 - (buf + start);
|
|
|
|
|
|
|
|
strbuf_attach(&tmp, buf, strlen(buf), strlen(buf) + 1);
|
|
|
|
if (is_encoding_utf8(encoding)) {
|
|
|
|
/* we have re-coded to UTF-8; drop the header */
|
|
|
|
strbuf_remove(&tmp, start, len);
|
|
|
|
} else {
|
|
|
|
/* just replaces XXXX in 'encoding XXXX\n' */
|
|
|
|
strbuf_splice(&tmp, start + strlen("encoding "),
|
|
|
|
len - strlen("encoding \n"),
|
|
|
|
encoding, strlen(encoding));
|
|
|
|
}
|
|
|
|
return strbuf_detach(&tmp, NULL);
|
|
|
|
}
|
|
|
|
|
2010-11-02 19:59:08 +00:00
|
|
|
char *logmsg_reencode(const struct commit *commit,
|
|
|
|
const char *output_encoding)
|
2007-11-04 19:15:06 +00:00
|
|
|
{
|
2009-05-18 23:44:39 +00:00
|
|
|
static const char *utf8 = "UTF-8";
|
2007-11-04 19:15:06 +00:00
|
|
|
const char *use_encoding;
|
|
|
|
char *encoding;
|
|
|
|
char *out;
|
|
|
|
|
|
|
|
if (!*output_encoding)
|
|
|
|
return NULL;
|
|
|
|
encoding = get_header(commit, "encoding");
|
|
|
|
use_encoding = encoding ? encoding : utf8;
|
|
|
|
if (!strcmp(use_encoding, output_encoding))
|
|
|
|
if (encoding) /* we'll strip encoding header later */
|
|
|
|
out = xstrdup(commit->buffer);
|
|
|
|
else
|
|
|
|
return NULL; /* nothing to do */
|
|
|
|
else
|
|
|
|
out = reencode_string(commit->buffer,
|
|
|
|
output_encoding, use_encoding);
|
|
|
|
if (out)
|
|
|
|
out = replace_encoding_header(out, output_encoding);
|
|
|
|
|
|
|
|
free(encoding);
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
2009-02-08 14:34:30 +00:00
|
|
|
static int mailmap_name(char *email, int email_len, char *name, int name_len)
|
2008-07-11 23:28:18 +00:00
|
|
|
{
|
2008-07-21 18:03:49 +00:00
|
|
|
static struct string_list *mail_map;
|
2008-07-11 23:28:18 +00:00
|
|
|
if (!mail_map) {
|
|
|
|
mail_map = xcalloc(1, sizeof(*mail_map));
|
2009-02-08 14:34:27 +00:00
|
|
|
read_mailmap(mail_map, NULL);
|
2008-07-11 23:28:18 +00:00
|
|
|
}
|
2009-02-08 14:34:30 +00:00
|
|
|
return mail_map->nr && map_user(mail_map, email, email_len, name, name_len);
|
2008-07-11 23:28:18 +00:00
|
|
|
}
|
|
|
|
|
2008-02-09 14:40:19 +00:00
|
|
|
static size_t format_person_part(struct strbuf *sb, char part,
|
2008-08-29 00:54:59 +00:00
|
|
|
const char *msg, int len, enum date_mode dmode)
|
2007-11-04 19:15:06 +00:00
|
|
|
{
|
2008-02-09 14:40:19 +00:00
|
|
|
/* currently all placeholders have same length */
|
|
|
|
const int placeholder_len = 2;
|
2012-03-11 09:25:43 +00:00
|
|
|
int tz;
|
2008-02-09 14:40:19 +00:00
|
|
|
unsigned long date = 0;
|
2009-02-08 14:34:30 +00:00
|
|
|
char person_name[1024];
|
|
|
|
char person_mail[1024];
|
2012-03-11 09:25:43 +00:00
|
|
|
struct ident_split s;
|
|
|
|
const char *name_start, *name_end, *mail_start, *mail_end;
|
2007-11-04 19:15:06 +00:00
|
|
|
|
2012-03-11 09:25:43 +00:00
|
|
|
if (split_ident_line(&s, msg, len) < 0)
|
2008-02-09 14:40:19 +00:00
|
|
|
goto skip;
|
|
|
|
|
2012-03-11 09:25:43 +00:00
|
|
|
name_start = s.name_begin;
|
|
|
|
name_end = s.name_end;
|
|
|
|
mail_start = s.mail_begin;
|
|
|
|
mail_end = s.mail_end;
|
2009-02-08 14:34:30 +00:00
|
|
|
|
|
|
|
if (part == 'N' || part == 'E') { /* mailmap lookup */
|
pretty: avoid buffer overflow in format_person_part
When we parse the name and email from a commit to
pretty-print them, we usually can just put the result
directly into our strbuf result. However, if we are going to
use the mailmap, then we must first copy them into a
NUL-terminated buffer to feed to the mailmap machinery.
We did so by using strlcpy into a static buffer, but we used
it wrong. We fed it the length of the substring we wanted to
copy, but never checked that that length was less than the
size of the destination buffer.
The simplest fix is to just use snprintf to copy the
substring properly while still respecting the destination
buffer's size. It might seem like replacing the static
buffer with a strbuf would help, but we need to feed a
static buffer to the mailmap machinery anyway, so there's
not much benefit to handling arbitrary sizes.
A more ideal solution would be for mailmap to grow an
interface that:
1. Takes a pointer and length combination, instead of
assuming a NUL-terminated string.
2. Returns a pointer to the mailmap's allocated string,
rather than copying it into the buffer.
Then we could avoid the need for an extra buffer entirely.
However, doing this would involve a lot of refactoring of
mailmap and of string_list (which mailmap uses to store the
map itself). For now, let's do the simplest thing to fix the
bug.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-05-22 05:45:08 +00:00
|
|
|
snprintf(person_name, sizeof(person_name), "%.*s",
|
|
|
|
(int)(name_end - name_start), name_start);
|
|
|
|
snprintf(person_mail, sizeof(person_mail), "%.*s",
|
|
|
|
(int)(mail_end - mail_start), mail_start);
|
2009-02-08 14:34:30 +00:00
|
|
|
mailmap_name(person_mail, sizeof(person_mail), person_name, sizeof(person_name));
|
|
|
|
name_start = person_name;
|
|
|
|
name_end = name_start + strlen(person_name);
|
|
|
|
mail_start = person_mail;
|
|
|
|
mail_end = mail_start + strlen(person_mail);
|
|
|
|
}
|
2008-07-11 23:28:18 +00:00
|
|
|
if (part == 'n' || part == 'N') { /* name */
|
2009-02-08 14:34:30 +00:00
|
|
|
strbuf_add(sb, name_start, name_end-name_start);
|
2008-02-09 14:40:19 +00:00
|
|
|
return placeholder_len;
|
2007-11-09 00:49:42 +00:00
|
|
|
}
|
2009-02-08 14:34:30 +00:00
|
|
|
if (part == 'e' || part == 'E') { /* email */
|
|
|
|
strbuf_add(sb, mail_start, mail_end-mail_start);
|
2008-02-09 14:40:19 +00:00
|
|
|
return placeholder_len;
|
2007-11-09 00:49:42 +00:00
|
|
|
}
|
2007-11-04 19:15:06 +00:00
|
|
|
|
2012-03-11 09:25:43 +00:00
|
|
|
if (!s.date_begin)
|
2008-02-09 14:40:19 +00:00
|
|
|
goto skip;
|
2007-11-04 19:15:06 +00:00
|
|
|
|
2012-03-11 09:25:43 +00:00
|
|
|
date = strtoul(s.date_begin, NULL, 10);
|
|
|
|
|
2007-11-09 00:49:42 +00:00
|
|
|
if (part == 't') { /* date, UNIX timestamp */
|
2012-03-11 09:25:43 +00:00
|
|
|
strbuf_add(sb, s.date_begin, s.date_end - s.date_begin);
|
2008-02-09 14:40:19 +00:00
|
|
|
return placeholder_len;
|
2007-11-09 00:49:42 +00:00
|
|
|
}
|
2007-11-04 19:15:06 +00:00
|
|
|
|
|
|
|
/* parse tz */
|
2012-03-11 09:25:43 +00:00
|
|
|
tz = strtoul(s.tz_begin + 1, NULL, 10);
|
|
|
|
if (*s.tz_begin == '-')
|
|
|
|
tz = -tz;
|
2007-11-04 19:15:06 +00:00
|
|
|
|
2007-11-09 00:49:42 +00:00
|
|
|
switch (part) {
|
|
|
|
case 'd': /* date */
|
2008-08-29 00:54:59 +00:00
|
|
|
strbuf_addstr(sb, show_date(date, tz, dmode));
|
2008-02-09 14:40:19 +00:00
|
|
|
return placeholder_len;
|
2007-11-09 00:49:42 +00:00
|
|
|
case 'D': /* date, RFC2822 style */
|
|
|
|
strbuf_addstr(sb, show_date(date, tz, DATE_RFC2822));
|
2008-02-09 14:40:19 +00:00
|
|
|
return placeholder_len;
|
2007-11-09 00:49:42 +00:00
|
|
|
case 'r': /* date, relative */
|
|
|
|
strbuf_addstr(sb, show_date(date, tz, DATE_RELATIVE));
|
2008-02-09 14:40:19 +00:00
|
|
|
return placeholder_len;
|
2007-11-09 00:49:42 +00:00
|
|
|
case 'i': /* date, ISO 8601 */
|
|
|
|
strbuf_addstr(sb, show_date(date, tz, DATE_ISO8601));
|
2008-02-09 14:40:19 +00:00
|
|
|
return placeholder_len;
|
2007-11-09 00:49:42 +00:00
|
|
|
}
|
2008-02-09 14:40:19 +00:00
|
|
|
|
|
|
|
skip:
|
|
|
|
/*
|
2012-03-11 09:25:43 +00:00
|
|
|
* reading from either a bogus commit, or a reflog entry with
|
|
|
|
* %gn, %ge, etc.; 'sb' cannot be updated, but we still need
|
|
|
|
* to compute a valid return value.
|
2008-02-09 14:40:19 +00:00
|
|
|
*/
|
|
|
|
if (part == 'n' || part == 'e' || part == 't' || part == 'd'
|
|
|
|
|| part == 'D' || part == 'r' || part == 'i')
|
|
|
|
return placeholder_len;
|
|
|
|
|
|
|
|
return 0; /* unknown placeholder */
|
2007-11-04 19:15:06 +00:00
|
|
|
}
|
|
|
|
|
2007-11-10 11:14:20 +00:00
|
|
|
struct chunk {
|
|
|
|
size_t off;
|
|
|
|
size_t len;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct format_commit_context {
|
|
|
|
const struct commit *commit;
|
2009-10-19 15:48:08 +00:00
|
|
|
const struct pretty_print_context *pretty_ctx;
|
2008-12-27 00:49:21 +00:00
|
|
|
unsigned commit_header_parsed:1;
|
|
|
|
unsigned commit_message_parsed:1;
|
2011-10-22 04:06:02 +00:00
|
|
|
unsigned commit_signature_parsed:1;
|
|
|
|
struct {
|
|
|
|
char *gpg_output;
|
|
|
|
char good_bad;
|
|
|
|
char *signer;
|
|
|
|
} signature;
|
2010-11-02 19:59:08 +00:00
|
|
|
char *message;
|
2009-10-17 21:04:19 +00:00
|
|
|
size_t width, indent1, indent2;
|
2007-11-10 11:14:20 +00:00
|
|
|
|
|
|
|
/* These offsets are relative to the start of the commit message. */
|
|
|
|
struct chunk author;
|
|
|
|
struct chunk committer;
|
|
|
|
struct chunk encoding;
|
2008-12-27 00:49:21 +00:00
|
|
|
size_t message_off;
|
|
|
|
size_t subject_off;
|
2007-11-10 11:14:20 +00:00
|
|
|
size_t body_off;
|
2007-11-10 11:18:26 +00:00
|
|
|
|
|
|
|
/* The following ones are relative to the result struct strbuf. */
|
|
|
|
struct chunk abbrev_commit_hash;
|
|
|
|
struct chunk abbrev_tree_hash;
|
|
|
|
struct chunk abbrev_parent_hashes;
|
2009-10-17 21:04:19 +00:00
|
|
|
size_t wrap_start;
|
2007-11-10 11:14:20 +00:00
|
|
|
};
|
|
|
|
|
2007-11-10 11:18:26 +00:00
|
|
|
static int add_again(struct strbuf *sb, struct chunk *chunk)
|
|
|
|
{
|
|
|
|
if (chunk->len) {
|
|
|
|
strbuf_adddup(sb, chunk->off, chunk->len);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We haven't seen this chunk before. Our caller is surely
|
|
|
|
* going to add it the hard way now. Remember the most likely
|
|
|
|
* start of the to-be-added chunk: the current end of the
|
|
|
|
* struct strbuf.
|
|
|
|
*/
|
|
|
|
chunk->off = sb->len;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-11-10 11:14:20 +00:00
|
|
|
static void parse_commit_header(struct format_commit_context *context)
|
2007-11-04 19:15:06 +00:00
|
|
|
{
|
2010-11-02 19:59:08 +00:00
|
|
|
const char *msg = context->message;
|
2007-11-04 19:15:06 +00:00
|
|
|
int i;
|
2007-11-10 11:14:20 +00:00
|
|
|
|
2008-12-27 00:49:21 +00:00
|
|
|
for (i = 0; msg[i]; i++) {
|
2007-11-10 11:14:20 +00:00
|
|
|
int eol;
|
|
|
|
for (eol = i; msg[eol] && msg[eol] != '\n'; eol++)
|
|
|
|
; /* do nothing */
|
|
|
|
|
|
|
|
if (i == eol) {
|
2008-12-27 00:49:21 +00:00
|
|
|
break;
|
2007-11-10 11:14:20 +00:00
|
|
|
} else if (!prefixcmp(msg + i, "author ")) {
|
|
|
|
context->author.off = i + 7;
|
|
|
|
context->author.len = eol - i - 7;
|
|
|
|
} else if (!prefixcmp(msg + i, "committer ")) {
|
|
|
|
context->committer.off = i + 10;
|
|
|
|
context->committer.len = eol - i - 10;
|
|
|
|
} else if (!prefixcmp(msg + i, "encoding ")) {
|
|
|
|
context->encoding.off = i + 9;
|
|
|
|
context->encoding.len = eol - i - 9;
|
|
|
|
}
|
|
|
|
i = eol;
|
|
|
|
}
|
2008-12-27 00:49:21 +00:00
|
|
|
context->message_off = i;
|
2007-11-10 11:14:20 +00:00
|
|
|
context->commit_header_parsed = 1;
|
|
|
|
}
|
|
|
|
|
2009-03-23 02:14:01 +00:00
|
|
|
static int istitlechar(char c)
|
|
|
|
{
|
|
|
|
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
|
|
|
|
(c >= '0' && c <= '9') || c == '.' || c == '_';
|
|
|
|
}
|
|
|
|
|
|
|
|
static void format_sanitized_subject(struct strbuf *sb, const char *msg)
|
|
|
|
{
|
|
|
|
size_t trimlen;
|
2009-03-31 23:24:38 +00:00
|
|
|
size_t start_len = sb->len;
|
2009-03-23 02:14:01 +00:00
|
|
|
int space = 2;
|
|
|
|
|
|
|
|
for (; *msg && *msg != '\n'; msg++) {
|
|
|
|
if (istitlechar(*msg)) {
|
|
|
|
if (space == 1)
|
|
|
|
strbuf_addch(sb, '-');
|
|
|
|
space = 0;
|
|
|
|
strbuf_addch(sb, *msg);
|
|
|
|
if (*msg == '.')
|
|
|
|
while (*(msg+1) == '.')
|
|
|
|
msg++;
|
|
|
|
} else
|
|
|
|
space |= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* trim any trailing '.' or '-' characters */
|
|
|
|
trimlen = 0;
|
2009-03-31 23:24:38 +00:00
|
|
|
while (sb->len - trimlen > start_len &&
|
|
|
|
(sb->buf[sb->len - 1 - trimlen] == '.'
|
|
|
|
|| sb->buf[sb->len - 1 - trimlen] == '-'))
|
2009-03-23 02:14:01 +00:00
|
|
|
trimlen++;
|
|
|
|
strbuf_remove(sb, sb->len - trimlen, trimlen);
|
|
|
|
}
|
|
|
|
|
2009-01-06 20:41:06 +00:00
|
|
|
const char *format_subject(struct strbuf *sb, const char *msg,
|
|
|
|
const char *line_separator)
|
2008-12-27 00:39:35 +00:00
|
|
|
{
|
|
|
|
int first = 1;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
const char *line = msg;
|
|
|
|
int linelen = get_one_line(line);
|
|
|
|
|
|
|
|
msg += linelen;
|
|
|
|
if (!linelen || is_empty_line(line, &linelen))
|
|
|
|
break;
|
|
|
|
|
2008-12-27 00:49:21 +00:00
|
|
|
if (!sb)
|
|
|
|
continue;
|
2008-12-27 00:39:35 +00:00
|
|
|
strbuf_grow(sb, linelen + 2);
|
|
|
|
if (!first)
|
|
|
|
strbuf_addstr(sb, line_separator);
|
|
|
|
strbuf_add(sb, line, linelen);
|
|
|
|
first = 0;
|
|
|
|
}
|
|
|
|
return msg;
|
|
|
|
}
|
|
|
|
|
2008-12-27 00:49:21 +00:00
|
|
|
static void parse_commit_message(struct format_commit_context *c)
|
|
|
|
{
|
2010-11-02 19:59:08 +00:00
|
|
|
const char *msg = c->message + c->message_off;
|
|
|
|
const char *start = c->message;
|
2008-12-27 00:49:21 +00:00
|
|
|
|
|
|
|
msg = skip_empty_lines(msg);
|
|
|
|
c->subject_off = msg - start;
|
|
|
|
|
|
|
|
msg = format_subject(NULL, msg, NULL);
|
|
|
|
msg = skip_empty_lines(msg);
|
|
|
|
c->body_off = msg - start;
|
|
|
|
|
|
|
|
c->commit_message_parsed = 1;
|
|
|
|
}
|
|
|
|
|
2008-09-04 21:40:03 +00:00
|
|
|
static void format_decoration(struct strbuf *sb, const struct commit *commit)
|
|
|
|
{
|
|
|
|
struct name_decoration *d;
|
|
|
|
const char *prefix = " (";
|
|
|
|
|
2009-08-15 14:23:12 +00:00
|
|
|
load_ref_decorations(DECORATE_SHORT_REFS);
|
2008-09-04 21:40:03 +00:00
|
|
|
d = lookup_decoration(&name_decoration, &commit->object);
|
|
|
|
while (d) {
|
|
|
|
strbuf_addstr(sb, prefix);
|
|
|
|
prefix = ", ";
|
|
|
|
strbuf_addstr(sb, d->name);
|
|
|
|
d = d->next;
|
|
|
|
}
|
|
|
|
if (prefix[0] == ',')
|
|
|
|
strbuf_addch(sb, ')');
|
|
|
|
}
|
|
|
|
|
2009-10-17 21:04:19 +00:00
|
|
|
static void strbuf_wrap(struct strbuf *sb, size_t pos,
|
|
|
|
size_t width, size_t indent1, size_t indent2)
|
|
|
|
{
|
|
|
|
struct strbuf tmp = STRBUF_INIT;
|
|
|
|
|
|
|
|
if (pos)
|
|
|
|
strbuf_add(&tmp, sb->buf, pos);
|
|
|
|
strbuf_add_wrapped_text(&tmp, sb->buf + pos,
|
|
|
|
(int) indent1, (int) indent2, (int) width);
|
|
|
|
strbuf_swap(&tmp, sb);
|
|
|
|
strbuf_release(&tmp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rewrap_message_tail(struct strbuf *sb,
|
|
|
|
struct format_commit_context *c,
|
|
|
|
size_t new_width, size_t new_indent1,
|
|
|
|
size_t new_indent2)
|
|
|
|
{
|
|
|
|
if (c->width == new_width && c->indent1 == new_indent1 &&
|
|
|
|
c->indent2 == new_indent2)
|
|
|
|
return;
|
2009-11-08 01:04:21 +00:00
|
|
|
if (c->wrap_start < sb->len)
|
2009-10-17 21:04:19 +00:00
|
|
|
strbuf_wrap(sb, c->wrap_start, c->width, c->indent1, c->indent2);
|
|
|
|
c->wrap_start = sb->len;
|
|
|
|
c->width = new_width;
|
|
|
|
c->indent1 = new_indent1;
|
|
|
|
c->indent2 = new_indent2;
|
|
|
|
}
|
|
|
|
|
2011-10-22 04:06:02 +00:00
|
|
|
static struct {
|
|
|
|
char result;
|
|
|
|
const char *check;
|
|
|
|
} signature_check[] = {
|
|
|
|
{ 'G', ": Good signature from " },
|
|
|
|
{ 'B', ": BAD signature from " },
|
|
|
|
};
|
|
|
|
|
|
|
|
static void parse_signature_lines(struct format_commit_context *ctx)
|
|
|
|
{
|
|
|
|
const char *buf = ctx->signature.gpg_output;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(signature_check); i++) {
|
|
|
|
const char *found = strstr(buf, signature_check[i].check);
|
|
|
|
const char *next;
|
|
|
|
if (!found)
|
|
|
|
continue;
|
|
|
|
ctx->signature.good_bad = signature_check[i].result;
|
|
|
|
found += strlen(signature_check[i].check);
|
|
|
|
next = strchrnul(found, '\n');
|
|
|
|
ctx->signature.signer = xmemdupz(found, next - found);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void parse_commit_signature(struct format_commit_context *ctx)
|
|
|
|
{
|
|
|
|
struct strbuf payload = STRBUF_INIT;
|
|
|
|
struct strbuf signature = STRBUF_INIT;
|
|
|
|
struct strbuf gpg_output = STRBUF_INIT;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
ctx->commit_signature_parsed = 1;
|
|
|
|
|
|
|
|
if (parse_signed_commit(ctx->commit->object.sha1,
|
|
|
|
&payload, &signature) <= 0)
|
|
|
|
goto out;
|
|
|
|
status = verify_signed_buffer(payload.buf, payload.len,
|
|
|
|
signature.buf, signature.len,
|
|
|
|
&gpg_output);
|
|
|
|
if (status && !gpg_output.len)
|
|
|
|
goto out;
|
|
|
|
ctx->signature.gpg_output = strbuf_detach(&gpg_output, NULL);
|
|
|
|
parse_signature_lines(ctx);
|
|
|
|
|
|
|
|
out:
|
|
|
|
strbuf_release(&gpg_output);
|
|
|
|
strbuf_release(&payload);
|
|
|
|
strbuf_release(&signature);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-12-16 11:40:24 +00:00
|
|
|
static int format_reflog_person(struct strbuf *sb,
|
|
|
|
char part,
|
|
|
|
struct reflog_walk_info *log,
|
|
|
|
enum date_mode dmode)
|
|
|
|
{
|
|
|
|
const char *ident;
|
|
|
|
|
|
|
|
if (!log)
|
|
|
|
return 2;
|
|
|
|
|
|
|
|
ident = get_reflog_ident(log);
|
|
|
|
if (!ident)
|
|
|
|
return 2;
|
|
|
|
|
|
|
|
return format_person_part(sb, part, ident, strlen(ident), dmode);
|
|
|
|
}
|
|
|
|
|
2009-10-05 06:43:32 +00:00
|
|
|
static size_t format_commit_one(struct strbuf *sb, const char *placeholder,
|
|
|
|
void *context)
|
2007-11-10 11:14:20 +00:00
|
|
|
{
|
|
|
|
struct format_commit_context *c = context;
|
|
|
|
const struct commit *commit = c->commit;
|
2010-11-02 19:59:08 +00:00
|
|
|
const char *msg = c->message;
|
2007-11-10 11:14:20 +00:00
|
|
|
struct commit_list *p;
|
2008-03-21 15:05:06 +00:00
|
|
|
int h1, h2;
|
2007-11-04 19:15:06 +00:00
|
|
|
|
|
|
|
/* these are independent of the commit */
|
2007-11-09 00:49:42 +00:00
|
|
|
switch (placeholder[0]) {
|
|
|
|
case 'C':
|
expand --pretty=format color options
Currently, the only colors available to --pretty=format
users are red, green, and blue. Rather than expand it with a
few new colors, this patch makes the usual config color
syntax available, including more colors, backgrounds, and
attributes.
Because colors are no longer bounded to a single word (e.g.,
%Cred), this uses a more advanced syntax that features a
beginning and end delimiter (but the old syntax still
works). So you can now do:
git log --pretty=tformat:'%C(yellow)%h%C(reset) %s'
to emulate --pretty=oneline, or even
git log --pretty=tformat:'%C(cyan magenta bold)%s%C(reset)'
if you want to relive the awesomeness of 4-color CGA.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-01-17 15:38:46 +00:00
|
|
|
if (placeholder[1] == '(') {
|
|
|
|
const char *end = strchr(placeholder + 2, ')');
|
|
|
|
char color[COLOR_MAXLEN];
|
|
|
|
if (!end)
|
|
|
|
return 0;
|
|
|
|
color_parse_mem(placeholder + 2,
|
|
|
|
end - (placeholder + 2),
|
|
|
|
"--pretty format", color);
|
|
|
|
strbuf_addstr(sb, color);
|
|
|
|
return end - placeholder + 1;
|
|
|
|
}
|
2008-02-09 14:40:19 +00:00
|
|
|
if (!prefixcmp(placeholder + 1, "red")) {
|
2009-02-13 21:53:40 +00:00
|
|
|
strbuf_addstr(sb, GIT_COLOR_RED);
|
2008-02-09 14:40:19 +00:00
|
|
|
return 4;
|
|
|
|
} else if (!prefixcmp(placeholder + 1, "green")) {
|
2009-02-13 21:53:40 +00:00
|
|
|
strbuf_addstr(sb, GIT_COLOR_GREEN);
|
2008-02-09 14:40:19 +00:00
|
|
|
return 6;
|
|
|
|
} else if (!prefixcmp(placeholder + 1, "blue")) {
|
2009-02-13 21:53:40 +00:00
|
|
|
strbuf_addstr(sb, GIT_COLOR_BLUE);
|
2008-02-09 14:40:19 +00:00
|
|
|
return 5;
|
|
|
|
} else if (!prefixcmp(placeholder + 1, "reset")) {
|
2009-02-13 21:53:40 +00:00
|
|
|
strbuf_addstr(sb, GIT_COLOR_RESET);
|
2008-02-09 14:40:19 +00:00
|
|
|
return 6;
|
|
|
|
} else
|
|
|
|
return 0;
|
2007-11-09 00:49:42 +00:00
|
|
|
case 'n': /* newline */
|
|
|
|
strbuf_addch(sb, '\n');
|
2008-02-09 14:40:19 +00:00
|
|
|
return 1;
|
2008-03-21 15:05:06 +00:00
|
|
|
case 'x':
|
|
|
|
/* %x00 == NUL, %x0a == LF, etc. */
|
|
|
|
if (0 <= (h1 = hexval_table[0xff & placeholder[1]]) &&
|
|
|
|
h1 <= 16 &&
|
|
|
|
0 <= (h2 = hexval_table[0xff & placeholder[2]]) &&
|
|
|
|
h2 <= 16) {
|
|
|
|
strbuf_addch(sb, (h1<<4)|h2);
|
|
|
|
return 3;
|
|
|
|
} else
|
|
|
|
return 0;
|
2009-10-17 21:04:19 +00:00
|
|
|
case 'w':
|
|
|
|
if (placeholder[1] == '(') {
|
|
|
|
unsigned long width = 0, indent1 = 0, indent2 = 0;
|
|
|
|
char *next;
|
|
|
|
const char *start = placeholder + 2;
|
|
|
|
const char *end = strchr(start, ')');
|
|
|
|
if (!end)
|
|
|
|
return 0;
|
|
|
|
if (end > start) {
|
|
|
|
width = strtoul(start, &next, 10);
|
|
|
|
if (*next == ',') {
|
|
|
|
indent1 = strtoul(next + 1, &next, 10);
|
|
|
|
if (*next == ',') {
|
|
|
|
indent2 = strtoul(next + 1,
|
|
|
|
&next, 10);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (*next != ')')
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
rewrap_message_tail(sb, c, width, indent1, indent2);
|
|
|
|
return end - placeholder + 1;
|
|
|
|
} else
|
|
|
|
return 0;
|
2007-11-09 00:49:42 +00:00
|
|
|
}
|
2007-11-04 19:15:06 +00:00
|
|
|
|
|
|
|
/* these depend on the commit */
|
|
|
|
if (!commit->object.parsed)
|
|
|
|
parse_object(commit->object.sha1);
|
|
|
|
|
2007-11-09 00:49:42 +00:00
|
|
|
switch (placeholder[0]) {
|
|
|
|
case 'H': /* commit hash */
|
|
|
|
strbuf_addstr(sb, sha1_to_hex(commit->object.sha1));
|
2008-02-09 14:40:19 +00:00
|
|
|
return 1;
|
2007-11-09 00:49:42 +00:00
|
|
|
case 'h': /* abbreviated commit hash */
|
2007-11-10 11:18:26 +00:00
|
|
|
if (add_again(sb, &c->abbrev_commit_hash))
|
2008-02-09 14:40:19 +00:00
|
|
|
return 1;
|
2007-11-09 00:49:42 +00:00
|
|
|
strbuf_addstr(sb, find_unique_abbrev(commit->object.sha1,
|
2010-05-04 03:18:57 +00:00
|
|
|
c->pretty_ctx->abbrev));
|
2007-11-10 11:18:26 +00:00
|
|
|
c->abbrev_commit_hash.len = sb->len - c->abbrev_commit_hash.off;
|
2008-02-09 14:40:19 +00:00
|
|
|
return 1;
|
2007-11-09 00:49:42 +00:00
|
|
|
case 'T': /* tree hash */
|
|
|
|
strbuf_addstr(sb, sha1_to_hex(commit->tree->object.sha1));
|
2008-02-09 14:40:19 +00:00
|
|
|
return 1;
|
2007-11-09 00:49:42 +00:00
|
|
|
case 't': /* abbreviated tree hash */
|
2007-11-10 11:18:26 +00:00
|
|
|
if (add_again(sb, &c->abbrev_tree_hash))
|
2008-02-09 14:40:19 +00:00
|
|
|
return 1;
|
2007-11-09 00:49:42 +00:00
|
|
|
strbuf_addstr(sb, find_unique_abbrev(commit->tree->object.sha1,
|
2010-05-04 03:18:57 +00:00
|
|
|
c->pretty_ctx->abbrev));
|
2007-11-10 11:18:26 +00:00
|
|
|
c->abbrev_tree_hash.len = sb->len - c->abbrev_tree_hash.off;
|
2008-02-09 14:40:19 +00:00
|
|
|
return 1;
|
2007-11-09 00:49:42 +00:00
|
|
|
case 'P': /* parent hashes */
|
|
|
|
for (p = commit->parents; p; p = p->next) {
|
|
|
|
if (p != commit->parents)
|
|
|
|
strbuf_addch(sb, ' ');
|
|
|
|
strbuf_addstr(sb, sha1_to_hex(p->item->object.sha1));
|
|
|
|
}
|
2008-02-09 14:40:19 +00:00
|
|
|
return 1;
|
2007-11-09 00:49:42 +00:00
|
|
|
case 'p': /* abbreviated parent hashes */
|
2007-11-10 11:18:26 +00:00
|
|
|
if (add_again(sb, &c->abbrev_parent_hashes))
|
2008-02-09 14:40:19 +00:00
|
|
|
return 1;
|
2007-11-09 00:49:42 +00:00
|
|
|
for (p = commit->parents; p; p = p->next) {
|
|
|
|
if (p != commit->parents)
|
|
|
|
strbuf_addch(sb, ' ');
|
|
|
|
strbuf_addstr(sb, find_unique_abbrev(
|
2010-05-04 03:18:57 +00:00
|
|
|
p->item->object.sha1,
|
|
|
|
c->pretty_ctx->abbrev));
|
2007-11-09 00:49:42 +00:00
|
|
|
}
|
2007-11-10 11:18:26 +00:00
|
|
|
c->abbrev_parent_hashes.len = sb->len -
|
|
|
|
c->abbrev_parent_hashes.off;
|
2008-02-09 14:40:19 +00:00
|
|
|
return 1;
|
2007-11-09 00:49:42 +00:00
|
|
|
case 'm': /* left/right/bottom */
|
2011-03-07 12:31:39 +00:00
|
|
|
strbuf_addstr(sb, get_revision_mark(NULL, commit));
|
2008-02-09 14:40:19 +00:00
|
|
|
return 1;
|
2008-09-04 21:40:03 +00:00
|
|
|
case 'd':
|
|
|
|
format_decoration(sb, commit);
|
|
|
|
return 1;
|
2009-10-19 15:48:10 +00:00
|
|
|
case 'g': /* reflog info */
|
|
|
|
switch(placeholder[1]) {
|
|
|
|
case 'd': /* reflog selector */
|
|
|
|
case 'D':
|
|
|
|
if (c->pretty_ctx->reflog_info)
|
|
|
|
get_reflog_selector(sb,
|
|
|
|
c->pretty_ctx->reflog_info,
|
|
|
|
c->pretty_ctx->date_mode,
|
2012-05-07 21:11:32 +00:00
|
|
|
c->pretty_ctx->date_mode_explicit,
|
2009-10-19 15:48:10 +00:00
|
|
|
(placeholder[1] == 'd'));
|
|
|
|
return 2;
|
|
|
|
case 's': /* reflog message */
|
|
|
|
if (c->pretty_ctx->reflog_info)
|
|
|
|
get_reflog_message(sb, c->pretty_ctx->reflog_info);
|
|
|
|
return 2;
|
2011-12-16 11:40:24 +00:00
|
|
|
case 'n':
|
|
|
|
case 'N':
|
|
|
|
case 'e':
|
|
|
|
case 'E':
|
|
|
|
return format_reflog_person(sb,
|
|
|
|
placeholder[1],
|
|
|
|
c->pretty_ctx->reflog_info,
|
|
|
|
c->pretty_ctx->date_mode);
|
2009-10-19 15:48:10 +00:00
|
|
|
}
|
|
|
|
return 0; /* unknown %g placeholder */
|
2009-10-09 10:22:05 +00:00
|
|
|
case 'N':
|
2012-10-18 01:51:47 +00:00
|
|
|
if (c->pretty_ctx->notes_message) {
|
|
|
|
strbuf_addstr(sb, c->pretty_ctx->notes_message);
|
2010-04-13 20:31:12 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
2007-11-09 00:49:42 +00:00
|
|
|
}
|
|
|
|
|
2011-10-22 04:06:02 +00:00
|
|
|
if (placeholder[0] == 'G') {
|
|
|
|
if (!c->commit_signature_parsed)
|
|
|
|
parse_commit_signature(c);
|
|
|
|
switch (placeholder[1]) {
|
|
|
|
case 'G':
|
|
|
|
if (c->signature.gpg_output)
|
|
|
|
strbuf_addstr(sb, c->signature.gpg_output);
|
|
|
|
break;
|
|
|
|
case '?':
|
|
|
|
switch (c->signature.good_bad) {
|
|
|
|
case 'G':
|
|
|
|
case 'B':
|
|
|
|
strbuf_addch(sb, c->signature.good_bad);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'S':
|
|
|
|
if (c->signature.signer)
|
|
|
|
strbuf_addstr(sb, c->signature.signer);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-11-09 00:49:42 +00:00
|
|
|
/* For the rest we have to parse the commit header. */
|
2007-11-10 11:14:20 +00:00
|
|
|
if (!c->commit_header_parsed)
|
|
|
|
parse_commit_header(c);
|
2007-11-04 19:15:06 +00:00
|
|
|
|
2007-11-10 11:14:20 +00:00
|
|
|
switch (placeholder[0]) {
|
2008-02-09 14:40:19 +00:00
|
|
|
case 'a': /* author ... */
|
|
|
|
return format_person_part(sb, placeholder[1],
|
2008-08-29 00:54:59 +00:00
|
|
|
msg + c->author.off, c->author.len,
|
2009-10-19 15:48:08 +00:00
|
|
|
c->pretty_ctx->date_mode);
|
2008-02-09 14:40:19 +00:00
|
|
|
case 'c': /* committer ... */
|
|
|
|
return format_person_part(sb, placeholder[1],
|
2008-08-29 00:54:59 +00:00
|
|
|
msg + c->committer.off, c->committer.len,
|
2009-10-19 15:48:08 +00:00
|
|
|
c->pretty_ctx->date_mode);
|
2008-02-09 14:40:19 +00:00
|
|
|
case 'e': /* encoding */
|
2007-11-10 11:14:20 +00:00
|
|
|
strbuf_add(sb, msg + c->encoding.off, c->encoding.len);
|
2008-02-09 14:40:19 +00:00
|
|
|
return 1;
|
2010-03-25 02:51:52 +00:00
|
|
|
case 'B': /* raw body */
|
|
|
|
/* message_off is always left at the initial newline */
|
|
|
|
strbuf_addstr(sb, msg + c->message_off + 1);
|
|
|
|
return 1;
|
2008-12-27 00:49:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Now we need to parse the commit message. */
|
|
|
|
if (!c->commit_message_parsed)
|
|
|
|
parse_commit_message(c);
|
|
|
|
|
|
|
|
switch (placeholder[0]) {
|
|
|
|
case 's': /* subject */
|
|
|
|
format_subject(sb, msg + c->subject_off, " ");
|
|
|
|
return 1;
|
2009-03-23 02:14:01 +00:00
|
|
|
case 'f': /* sanitized subject */
|
|
|
|
format_sanitized_subject(sb, msg + c->subject_off);
|
|
|
|
return 1;
|
2008-02-09 14:40:19 +00:00
|
|
|
case 'b': /* body */
|
2007-11-10 11:14:20 +00:00
|
|
|
strbuf_addstr(sb, msg + c->body_off);
|
2008-02-09 14:40:19 +00:00
|
|
|
return 1;
|
2007-11-04 19:15:06 +00:00
|
|
|
}
|
2008-02-09 14:40:19 +00:00
|
|
|
return 0; /* unknown placeholder */
|
2007-11-09 00:49:42 +00:00
|
|
|
}
|
|
|
|
|
2009-10-05 06:43:32 +00:00
|
|
|
static size_t format_commit_item(struct strbuf *sb, const char *placeholder,
|
|
|
|
void *context)
|
|
|
|
{
|
|
|
|
int consumed;
|
|
|
|
size_t orig_len;
|
|
|
|
enum {
|
|
|
|
NO_MAGIC,
|
|
|
|
ADD_LF_BEFORE_NON_EMPTY,
|
|
|
|
DEL_LF_BEFORE_EMPTY,
|
2010-06-22 16:45:22 +00:00
|
|
|
ADD_SP_BEFORE_NON_EMPTY
|
2009-10-05 06:43:32 +00:00
|
|
|
} magic = NO_MAGIC;
|
|
|
|
|
|
|
|
switch (placeholder[0]) {
|
|
|
|
case '-':
|
|
|
|
magic = DEL_LF_BEFORE_EMPTY;
|
|
|
|
break;
|
|
|
|
case '+':
|
|
|
|
magic = ADD_LF_BEFORE_NON_EMPTY;
|
|
|
|
break;
|
2010-06-14 16:12:29 +00:00
|
|
|
case ' ':
|
|
|
|
magic = ADD_SP_BEFORE_NON_EMPTY;
|
|
|
|
break;
|
2009-10-05 06:43:32 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (magic != NO_MAGIC)
|
|
|
|
placeholder++;
|
|
|
|
|
|
|
|
orig_len = sb->len;
|
|
|
|
consumed = format_commit_one(sb, placeholder, context);
|
|
|
|
if (magic == NO_MAGIC)
|
|
|
|
return consumed;
|
|
|
|
|
|
|
|
if ((orig_len == sb->len) && magic == DEL_LF_BEFORE_EMPTY) {
|
|
|
|
while (sb->len && sb->buf[sb->len - 1] == '\n')
|
|
|
|
strbuf_setlen(sb, sb->len - 1);
|
2010-06-14 16:12:29 +00:00
|
|
|
} else if (orig_len != sb->len) {
|
|
|
|
if (magic == ADD_LF_BEFORE_NON_EMPTY)
|
|
|
|
strbuf_insert(sb, orig_len, "\n", 1);
|
|
|
|
else if (magic == ADD_SP_BEFORE_NON_EMPTY)
|
|
|
|
strbuf_insert(sb, orig_len, " ", 1);
|
2009-10-05 06:43:32 +00:00
|
|
|
}
|
|
|
|
return consumed + 1;
|
|
|
|
}
|
|
|
|
|
2010-04-13 20:31:12 +00:00
|
|
|
static size_t userformat_want_item(struct strbuf *sb, const char *placeholder,
|
|
|
|
void *context)
|
|
|
|
{
|
|
|
|
struct userformat_want *w = context;
|
|
|
|
|
2010-06-14 16:12:29 +00:00
|
|
|
if (*placeholder == '+' || *placeholder == '-' || *placeholder == ' ')
|
2010-04-13 20:31:12 +00:00
|
|
|
placeholder++;
|
|
|
|
|
|
|
|
switch (*placeholder) {
|
|
|
|
case 'N':
|
|
|
|
w->notes = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void userformat_find_requirements(const char *fmt, struct userformat_want *w)
|
|
|
|
{
|
|
|
|
struct strbuf dummy = STRBUF_INIT;
|
|
|
|
|
|
|
|
if (!fmt) {
|
|
|
|
if (!user_format)
|
|
|
|
return;
|
|
|
|
fmt = user_format;
|
|
|
|
}
|
2011-05-25 19:23:44 +00:00
|
|
|
strbuf_expand(&dummy, fmt, userformat_want_item, w);
|
2010-04-13 20:31:12 +00:00
|
|
|
strbuf_release(&dummy);
|
|
|
|
}
|
|
|
|
|
2007-11-09 00:49:42 +00:00
|
|
|
void format_commit_message(const struct commit *commit,
|
2009-10-16 05:59:41 +00:00
|
|
|
const char *format, struct strbuf *sb,
|
2009-10-19 15:48:08 +00:00
|
|
|
const struct pretty_print_context *pretty_ctx)
|
2007-11-09 00:49:42 +00:00
|
|
|
{
|
2007-11-10 11:14:20 +00:00
|
|
|
struct format_commit_context context;
|
2010-11-02 19:59:08 +00:00
|
|
|
static const char utf8[] = "UTF-8";
|
|
|
|
const char *output_enc = pretty_ctx->output_encoding;
|
2007-11-10 11:14:20 +00:00
|
|
|
|
|
|
|
memset(&context, 0, sizeof(context));
|
|
|
|
context.commit = commit;
|
2009-10-19 15:48:08 +00:00
|
|
|
context.pretty_ctx = pretty_ctx;
|
2009-10-17 21:04:19 +00:00
|
|
|
context.wrap_start = sb->len;
|
2010-11-02 19:59:08 +00:00
|
|
|
context.message = commit->buffer;
|
|
|
|
if (output_enc) {
|
2011-10-23 11:51:34 +00:00
|
|
|
char *enc = get_header(commit, "encoding");
|
2011-10-23 11:51:35 +00:00
|
|
|
if (strcmp(enc ? enc : utf8, output_enc)) {
|
2010-11-02 19:59:08 +00:00
|
|
|
context.message = logmsg_reencode(commit, output_enc);
|
2011-10-23 11:51:35 +00:00
|
|
|
if (!context.message)
|
|
|
|
context.message = commit->buffer;
|
|
|
|
}
|
2011-10-23 11:51:34 +00:00
|
|
|
free(enc);
|
2010-11-02 19:59:08 +00:00
|
|
|
}
|
|
|
|
|
2008-02-09 14:40:19 +00:00
|
|
|
strbuf_expand(sb, format, format_commit_item, &context);
|
2009-10-17 21:04:19 +00:00
|
|
|
rewrap_message_tail(sb, &context, 0, 0, 0);
|
2010-11-02 19:59:08 +00:00
|
|
|
|
|
|
|
if (context.message != commit->buffer)
|
|
|
|
free(context.message);
|
2011-10-22 04:06:02 +00:00
|
|
|
free(context.signature.gpg_output);
|
|
|
|
free(context.signature.signer);
|
2007-11-04 19:15:06 +00:00
|
|
|
}
|
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
static void pp_header(const struct pretty_print_context *pp,
|
2007-11-04 19:15:06 +00:00
|
|
|
const char *encoding,
|
|
|
|
const struct commit *commit,
|
|
|
|
const char **msg_p,
|
|
|
|
struct strbuf *sb)
|
|
|
|
{
|
|
|
|
int parents_shown = 0;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
const char *line = *msg_p;
|
|
|
|
int linelen = get_one_line(*msg_p);
|
|
|
|
|
|
|
|
if (!linelen)
|
|
|
|
return;
|
|
|
|
*msg_p += linelen;
|
|
|
|
|
|
|
|
if (linelen == 1)
|
|
|
|
/* End of header */
|
|
|
|
return;
|
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->fmt == CMIT_FMT_RAW) {
|
2007-11-04 19:15:06 +00:00
|
|
|
strbuf_add(sb, line, linelen);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!memcmp(line, "parent ", 7)) {
|
|
|
|
if (linelen != 48)
|
|
|
|
die("bad parent line in commit");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!parents_shown) {
|
|
|
|
struct commit_list *parent;
|
|
|
|
int num;
|
|
|
|
for (parent = commit->parents, num = 0;
|
|
|
|
parent;
|
|
|
|
parent = parent->next, num++)
|
|
|
|
;
|
|
|
|
/* with enough slop */
|
|
|
|
strbuf_grow(sb, num * 50 + 20);
|
2011-05-26 22:27:49 +00:00
|
|
|
add_merge_info(pp, sb, commit);
|
2007-11-04 19:15:06 +00:00
|
|
|
parents_shown = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* MEDIUM == DEFAULT shows only author with dates.
|
|
|
|
* FULL shows both authors but not dates.
|
|
|
|
* FULLER shows both authors and dates.
|
|
|
|
*/
|
|
|
|
if (!memcmp(line, "author ", 7)) {
|
|
|
|
strbuf_grow(sb, linelen + 80);
|
2011-05-26 22:27:49 +00:00
|
|
|
pp_user_info(pp, "Author", sb, line + 7, encoding);
|
2007-11-04 19:15:06 +00:00
|
|
|
}
|
|
|
|
if (!memcmp(line, "committer ", 10) &&
|
2011-05-26 22:27:49 +00:00
|
|
|
(pp->fmt == CMIT_FMT_FULL || pp->fmt == CMIT_FMT_FULLER)) {
|
2007-11-04 19:15:06 +00:00
|
|
|
strbuf_grow(sb, linelen + 80);
|
2011-05-26 22:27:49 +00:00
|
|
|
pp_user_info(pp, "Commit", sb, line + 10, encoding);
|
2007-11-04 19:15:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
void pp_title_line(const struct pretty_print_context *pp,
|
2008-02-19 03:56:08 +00:00
|
|
|
const char **msg_p,
|
|
|
|
struct strbuf *sb,
|
|
|
|
const char *encoding,
|
2008-03-15 07:09:20 +00:00
|
|
|
int need_8bit_cte)
|
2007-11-04 19:15:06 +00:00
|
|
|
{
|
|
|
|
struct strbuf title;
|
|
|
|
|
|
|
|
strbuf_init(&title, 80);
|
2011-05-26 22:28:17 +00:00
|
|
|
*msg_p = format_subject(&title, *msg_p,
|
|
|
|
pp->preserve_subject ? "\n" : " ");
|
2007-11-04 19:15:06 +00:00
|
|
|
|
|
|
|
strbuf_grow(sb, title.len + 1024);
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->subject) {
|
|
|
|
strbuf_addstr(sb, pp->subject);
|
2007-11-04 19:15:06 +00:00
|
|
|
add_rfc2047(sb, title.buf, title.len, encoding);
|
|
|
|
} else {
|
|
|
|
strbuf_addbuf(sb, &title);
|
|
|
|
}
|
|
|
|
strbuf_addch(sb, '\n');
|
|
|
|
|
2008-03-15 00:10:09 +00:00
|
|
|
if (need_8bit_cte > 0) {
|
2007-11-04 19:15:06 +00:00
|
|
|
const char *header_fmt =
|
|
|
|
"MIME-Version: 1.0\n"
|
|
|
|
"Content-Type: text/plain; charset=%s\n"
|
|
|
|
"Content-Transfer-Encoding: 8bit\n";
|
|
|
|
strbuf_addf(sb, header_fmt, encoding);
|
|
|
|
}
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->after_subject) {
|
|
|
|
strbuf_addstr(sb, pp->after_subject);
|
2007-11-04 19:15:06 +00:00
|
|
|
}
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->fmt == CMIT_FMT_EMAIL) {
|
2007-11-04 19:15:06 +00:00
|
|
|
strbuf_addch(sb, '\n');
|
|
|
|
}
|
|
|
|
strbuf_release(&title);
|
|
|
|
}
|
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
void pp_remainder(const struct pretty_print_context *pp,
|
2008-02-19 03:56:08 +00:00
|
|
|
const char **msg_p,
|
|
|
|
struct strbuf *sb,
|
|
|
|
int indent)
|
2007-11-04 19:15:06 +00:00
|
|
|
{
|
|
|
|
int first = 1;
|
|
|
|
for (;;) {
|
|
|
|
const char *line = *msg_p;
|
|
|
|
int linelen = get_one_line(line);
|
|
|
|
*msg_p += linelen;
|
|
|
|
|
|
|
|
if (!linelen)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (is_empty_line(line, &linelen)) {
|
|
|
|
if (first)
|
|
|
|
continue;
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->fmt == CMIT_FMT_SHORT)
|
2007-11-04 19:15:06 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
first = 0;
|
|
|
|
|
|
|
|
strbuf_grow(sb, linelen + indent + 20);
|
|
|
|
if (indent) {
|
|
|
|
memset(sb->buf + sb->len, ' ', indent);
|
|
|
|
strbuf_setlen(sb, sb->len + indent);
|
|
|
|
}
|
|
|
|
strbuf_add(sb, line, linelen);
|
|
|
|
strbuf_addch(sb, '\n');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
void pretty_print_commit(const struct pretty_print_context *pp,
|
|
|
|
const struct commit *commit,
|
|
|
|
struct strbuf *sb)
|
2007-11-04 19:15:06 +00:00
|
|
|
{
|
|
|
|
unsigned long beginning_of_body;
|
|
|
|
int indent = 4;
|
|
|
|
const char *msg = commit->buffer;
|
|
|
|
char *reencoded;
|
|
|
|
const char *encoding;
|
2011-05-26 22:27:49 +00:00
|
|
|
int need_8bit_cte = pp->need_8bit_cte;
|
2007-11-04 19:15:06 +00:00
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->fmt == CMIT_FMT_USERFORMAT) {
|
|
|
|
format_commit_message(commit, user_format, sb, pp);
|
2007-11-04 19:15:06 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-10-18 00:12:55 +00:00
|
|
|
encoding = get_log_output_encoding();
|
|
|
|
reencoded = logmsg_reencode(commit, encoding);
|
2007-11-04 19:15:06 +00:00
|
|
|
if (reencoded) {
|
|
|
|
msg = reencoded;
|
|
|
|
}
|
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->fmt == CMIT_FMT_ONELINE || pp->fmt == CMIT_FMT_EMAIL)
|
2007-11-04 19:15:06 +00:00
|
|
|
indent = 0;
|
|
|
|
|
2008-03-15 00:10:09 +00:00
|
|
|
/*
|
|
|
|
* We need to check and emit Content-type: to mark it
|
|
|
|
* as 8-bit if we haven't done so.
|
2007-11-04 19:15:06 +00:00
|
|
|
*/
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->fmt == CMIT_FMT_EMAIL && need_8bit_cte == 0) {
|
2007-11-04 19:15:06 +00:00
|
|
|
int i, ch, in_body;
|
|
|
|
|
|
|
|
for (in_body = i = 0; (ch = msg[i]); i++) {
|
|
|
|
if (!in_body) {
|
|
|
|
/* author could be non 7-bit ASCII but
|
|
|
|
* the log may be so; skip over the
|
|
|
|
* header part first.
|
|
|
|
*/
|
|
|
|
if (ch == '\n' && msg[i+1] == '\n')
|
|
|
|
in_body = 1;
|
|
|
|
}
|
|
|
|
else if (non_ascii(ch)) {
|
2008-03-15 00:10:09 +00:00
|
|
|
need_8bit_cte = 1;
|
2007-11-04 19:15:06 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
pp_header(pp, encoding, commit, &msg, sb);
|
|
|
|
if (pp->fmt != CMIT_FMT_ONELINE && !pp->subject) {
|
2007-11-04 19:15:06 +00:00
|
|
|
strbuf_addch(sb, '\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Skip excess blank lines at the beginning of body, if any... */
|
2008-12-27 00:32:49 +00:00
|
|
|
msg = skip_empty_lines(msg);
|
2007-11-04 19:15:06 +00:00
|
|
|
|
|
|
|
/* These formats treat the title line specially. */
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->fmt == CMIT_FMT_ONELINE || pp->fmt == CMIT_FMT_EMAIL)
|
|
|
|
pp_title_line(pp, &msg, sb, encoding, need_8bit_cte);
|
2007-11-04 19:15:06 +00:00
|
|
|
|
|
|
|
beginning_of_body = sb->len;
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->fmt != CMIT_FMT_ONELINE)
|
|
|
|
pp_remainder(pp, &msg, sb, indent);
|
2007-11-04 19:15:06 +00:00
|
|
|
strbuf_rtrim(sb);
|
|
|
|
|
|
|
|
/* Make sure there is an EOLN for the non-oneline case */
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->fmt != CMIT_FMT_ONELINE)
|
2007-11-04 19:15:06 +00:00
|
|
|
strbuf_addch(sb, '\n');
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The caller may append additional body text in e-mail
|
|
|
|
* format. Make sure we did not strip the blank line
|
|
|
|
* between the header and the body.
|
|
|
|
*/
|
2011-05-26 22:27:49 +00:00
|
|
|
if (pp->fmt == CMIT_FMT_EMAIL && sb->len <= beginning_of_body)
|
2007-11-04 19:15:06 +00:00
|
|
|
strbuf_addch(sb, '\n');
|
2009-10-09 10:21:57 +00:00
|
|
|
|
2007-11-04 19:15:06 +00:00
|
|
|
free(reencoded);
|
|
|
|
}
|
2011-05-26 22:27:24 +00:00
|
|
|
|
|
|
|
void pp_commit_easy(enum cmit_fmt fmt, const struct commit *commit,
|
|
|
|
struct strbuf *sb)
|
|
|
|
{
|
|
|
|
struct pretty_print_context pp = {0};
|
2011-05-26 22:27:49 +00:00
|
|
|
pp.fmt = fmt;
|
|
|
|
pretty_print_commit(&pp, commit, sb);
|
2011-05-26 22:27:24 +00:00
|
|
|
}
|