2006-10-22 13:23:31 +02:00
|
|
|
#include "builtin.h"
|
|
|
|
#include "cache.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "diff.h"
|
2008-07-21 20:03:49 +02:00
|
|
|
#include "string-list.h"
|
2006-10-22 13:23:31 +02:00
|
|
|
#include "revision.h"
|
2006-12-22 22:15:59 +01:00
|
|
|
#include "utf8.h"
|
2007-04-27 09:41:15 +02:00
|
|
|
#include "mailmap.h"
|
2008-02-26 00:24:14 +01:00
|
|
|
#include "shortlog.h"
|
2008-07-09 23:38:33 +02:00
|
|
|
#include "parse-options.h"
|
2006-10-22 13:23:31 +02:00
|
|
|
|
2008-07-09 23:38:33 +02:00
|
|
|
static char const * const shortlog_usage[] = {
|
2015-01-13 08:44:47 +01:00
|
|
|
N_("git shortlog [<options>] [<revision-range>] [[--] [<path>...]]"),
|
2008-07-09 23:38:33 +02:00
|
|
|
NULL
|
|
|
|
};
|
2006-10-22 13:23:31 +02:00
|
|
|
|
2016-01-18 21:02:59 +01:00
|
|
|
/*
|
|
|
|
* The util field of our string_list_items will contain one of two things:
|
|
|
|
*
|
|
|
|
* - if --summary is not in use, it will point to a string list of the
|
|
|
|
* oneline subjects assigned to this author
|
|
|
|
*
|
|
|
|
* - if --summary is in use, we don't need that list; we only need to know
|
|
|
|
* its size. So we abuse the pointer slot to store our integer counter.
|
|
|
|
*
|
|
|
|
* This macro accesses the latter.
|
|
|
|
*/
|
|
|
|
#define UTIL_TO_INT(x) ((intptr_t)(x)->util)
|
|
|
|
|
|
|
|
static int compare_by_counter(const void *a1, const void *a2)
|
|
|
|
{
|
|
|
|
const struct string_list_item *i1 = a1, *i2 = a2;
|
|
|
|
return UTIL_TO_INT(i2) - UTIL_TO_INT(i1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int compare_by_list(const void *a1, const void *a2)
|
2006-10-22 13:23:31 +02:00
|
|
|
{
|
2008-07-21 20:03:49 +02:00
|
|
|
const struct string_list_item *i1 = a1, *i2 = a2;
|
|
|
|
const struct string_list *l1 = i1->util, *l2 = i2->util;
|
2006-10-22 13:23:31 +02:00
|
|
|
|
|
|
|
if (l1->nr < l2->nr)
|
2006-11-21 21:12:06 +01:00
|
|
|
return 1;
|
2006-10-22 13:23:31 +02:00
|
|
|
else if (l1->nr == l2->nr)
|
|
|
|
return 0;
|
|
|
|
else
|
2006-11-21 21:12:06 +01:00
|
|
|
return -1;
|
2006-10-22 13:23:31 +02:00
|
|
|
}
|
|
|
|
|
2008-02-26 00:24:14 +01:00
|
|
|
static void insert_one_record(struct shortlog *log,
|
2007-12-08 02:07:41 +01:00
|
|
|
const char *author,
|
|
|
|
const char *oneline)
|
2006-10-22 13:23:31 +02:00
|
|
|
{
|
2008-07-21 20:03:49 +02:00
|
|
|
struct string_list_item *item;
|
2013-01-05 22:26:40 +01:00
|
|
|
const char *mailbuf, *namebuf;
|
|
|
|
size_t namelen, maillen;
|
|
|
|
struct strbuf namemailbuf = STRBUF_INIT;
|
2013-01-05 22:26:38 +01:00
|
|
|
struct ident_split ident;
|
2007-12-08 02:07:41 +01:00
|
|
|
|
2013-01-05 22:26:38 +01:00
|
|
|
if (split_ident_line(&ident, author, strlen(author)))
|
2007-12-08 02:07:41 +01:00
|
|
|
return;
|
2009-02-08 15:34:30 +01:00
|
|
|
|
2013-01-05 22:26:40 +01:00
|
|
|
namebuf = ident.name_begin;
|
|
|
|
mailbuf = ident.mail_begin;
|
|
|
|
namelen = ident.name_end - ident.name_begin;
|
|
|
|
maillen = ident.mail_end - ident.mail_begin;
|
2009-02-08 15:34:30 +01:00
|
|
|
|
2013-01-05 22:26:40 +01:00
|
|
|
map_user(&log->mailmap, &mailbuf, &maillen, &namebuf, &namelen);
|
|
|
|
strbuf_add(&namemailbuf, namebuf, namelen);
|
2009-02-08 15:34:30 +01:00
|
|
|
|
2013-01-05 22:26:40 +01:00
|
|
|
if (log->email)
|
|
|
|
strbuf_addf(&namemailbuf, " <%.*s>", (int)maillen, mailbuf);
|
2006-10-22 13:23:31 +02:00
|
|
|
|
2013-01-05 22:26:40 +01:00
|
|
|
item = string_list_insert(&log->list, namemailbuf.buf);
|
2006-10-22 13:23:31 +02:00
|
|
|
|
2016-01-18 21:02:56 +01:00
|
|
|
if (log->summary)
|
2016-01-18 21:02:59 +01:00
|
|
|
item->util = (void *)(UTIL_TO_INT(item) + 1);
|
2016-01-18 21:02:56 +01:00
|
|
|
else {
|
|
|
|
const char *dot3 = log->common_repo_prefix;
|
|
|
|
char *buffer, *p;
|
|
|
|
struct strbuf subject = STRBUF_INIT;
|
|
|
|
const char *eol;
|
|
|
|
|
|
|
|
/* Skip any leading whitespace, including any blank lines. */
|
|
|
|
while (*oneline && isspace(*oneline))
|
|
|
|
oneline++;
|
|
|
|
eol = strchr(oneline, '\n');
|
|
|
|
if (!eol)
|
|
|
|
eol = oneline + strlen(oneline);
|
|
|
|
if (starts_with(oneline, "[PATCH")) {
|
|
|
|
char *eob = strchr(oneline, ']');
|
|
|
|
if (eob && (!eol || eob < eol))
|
|
|
|
oneline = eob + 1;
|
|
|
|
}
|
|
|
|
while (*oneline && isspace(*oneline) && *oneline != '\n')
|
|
|
|
oneline++;
|
|
|
|
format_subject(&subject, oneline, " ");
|
|
|
|
buffer = strbuf_detach(&subject, NULL);
|
2006-10-22 13:23:31 +02:00
|
|
|
|
2016-01-18 21:02:56 +01:00
|
|
|
if (dot3) {
|
|
|
|
int dot3len = strlen(dot3);
|
|
|
|
if (dot3len > 5) {
|
|
|
|
while ((p = strstr(buffer, dot3)) != NULL) {
|
|
|
|
int taillen = strlen(p) - dot3len;
|
|
|
|
memcpy(p, "/.../", 5);
|
|
|
|
memmove(p + 5, p + dot3len, taillen + 1);
|
|
|
|
}
|
2006-11-25 09:01:27 +01:00
|
|
|
}
|
|
|
|
}
|
2006-10-22 13:23:31 +02:00
|
|
|
|
2016-01-18 21:02:59 +01:00
|
|
|
if (item->util == NULL)
|
|
|
|
item->util = xcalloc(1, sizeof(struct string_list));
|
2016-01-18 21:02:56 +01:00
|
|
|
string_list_append(item->util, buffer);
|
|
|
|
}
|
2006-10-22 13:23:31 +02:00
|
|
|
}
|
|
|
|
|
2008-02-26 00:24:14 +01:00
|
|
|
static void read_from_stdin(struct shortlog *log)
|
2006-10-22 13:23:31 +02:00
|
|
|
{
|
2016-01-18 21:02:44 +01:00
|
|
|
struct strbuf author = STRBUF_INIT;
|
|
|
|
struct strbuf oneline = STRBUF_INIT;
|
2007-12-08 02:07:41 +01:00
|
|
|
|
2016-01-29 01:10:14 +01:00
|
|
|
while (strbuf_getline_lf(&author, stdin) != EOF) {
|
2016-01-18 21:02:40 +01:00
|
|
|
const char *v;
|
2016-01-18 21:02:44 +01:00
|
|
|
if (!skip_prefix(author.buf, "Author: ", &v) &&
|
|
|
|
!skip_prefix(author.buf, "author ", &v))
|
2007-12-08 02:07:41 +01:00
|
|
|
continue;
|
2016-01-29 01:10:14 +01:00
|
|
|
while (strbuf_getline_lf(&oneline, stdin) != EOF &&
|
2016-01-18 21:02:44 +01:00
|
|
|
oneline.len)
|
2007-12-08 02:07:41 +01:00
|
|
|
; /* discard headers */
|
2016-01-29 01:10:14 +01:00
|
|
|
while (strbuf_getline_lf(&oneline, stdin) != EOF &&
|
2016-01-18 21:02:44 +01:00
|
|
|
!oneline.len)
|
2007-12-08 02:07:41 +01:00
|
|
|
; /* discard blanks */
|
2016-01-18 21:02:44 +01:00
|
|
|
insert_one_record(log, v, oneline.buf);
|
2006-10-22 13:23:31 +02:00
|
|
|
}
|
2016-01-18 21:02:44 +01:00
|
|
|
strbuf_release(&author);
|
|
|
|
strbuf_release(&oneline);
|
2006-10-22 13:23:31 +02:00
|
|
|
}
|
|
|
|
|
2008-02-26 00:24:14 +01:00
|
|
|
void shortlog_add_commit(struct shortlog *log, struct commit *commit)
|
2006-10-22 13:23:31 +02:00
|
|
|
{
|
2016-01-18 21:02:48 +01:00
|
|
|
struct strbuf author = STRBUF_INIT;
|
|
|
|
struct strbuf oneline = STRBUF_INIT;
|
|
|
|
struct pretty_print_context ctx = {0};
|
|
|
|
|
|
|
|
ctx.fmt = CMIT_FMT_USERFORMAT;
|
|
|
|
ctx.abbrev = log->abbrev;
|
|
|
|
ctx.subject = "";
|
|
|
|
ctx.after_subject = "";
|
|
|
|
ctx.date_mode.type = DATE_NORMAL;
|
|
|
|
ctx.output_encoding = get_log_output_encoding();
|
|
|
|
|
|
|
|
format_commit_message(commit, "%an <%ae>", &author, &ctx);
|
2016-01-18 21:02:52 +01:00
|
|
|
if (!log->summary) {
|
|
|
|
if (log->user_format)
|
|
|
|
pretty_print_commit(&ctx, commit, &oneline);
|
2008-02-26 00:24:14 +01:00
|
|
|
else
|
2016-01-18 21:02:52 +01:00
|
|
|
format_commit_message(commit, "%s", &oneline, &ctx);
|
shortlog: ignore commits with missing authors
Most of git's traversals are robust against minor breakages
in commit data. For example, "git log" will still output an
entry for a commit that has a broken encoding or missing
author, and will not abort the whole operation.
Shortlog, on the other hand, will die as soon as it sees a
commit without an author, meaning that a repository with
a broken commit cannot get any shortlog output at all.
Let's downgrade this fatal error to a warning, and continue
the operation.
We simply ignore the commit and do not count it in the total
(since we do not have any author under which to file it).
Alternatively, we could output some kind of "<empty>" record
to collect these bogus commits. It is probably not worth it,
though; we have already warned to stderr, so the user is
aware that such bogosities exist, and any placeholder we
came up with would either be syntactically invalid, or would
potentially conflict with real data.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-09-18 23:14:00 +02:00
|
|
|
}
|
2016-01-18 21:02:48 +01:00
|
|
|
|
|
|
|
insert_one_record(log, author.buf, oneline.len ? oneline.buf : "<none>");
|
|
|
|
|
|
|
|
strbuf_release(&author);
|
|
|
|
strbuf_release(&oneline);
|
2008-02-26 00:24:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void get_from_rev(struct rev_info *rev, struct shortlog *log)
|
|
|
|
{
|
|
|
|
struct commit *commit;
|
|
|
|
|
|
|
|
if (prepare_revision_walk(rev))
|
2011-02-23 00:42:32 +01:00
|
|
|
die(_("revision walk setup failed"));
|
2008-02-26 00:24:14 +01:00
|
|
|
while ((commit = get_revision(rev)) != NULL)
|
|
|
|
shortlog_add_commit(log, commit);
|
2006-10-22 13:23:31 +02:00
|
|
|
}
|
|
|
|
|
2008-07-09 23:38:33 +02:00
|
|
|
static int parse_uint(char const **arg, int comma, int defval)
|
2007-04-08 10:28:00 +02:00
|
|
|
{
|
|
|
|
unsigned long ul;
|
|
|
|
int ret;
|
|
|
|
char *endp;
|
|
|
|
|
|
|
|
ul = strtoul(*arg, &endp, 10);
|
2008-07-09 23:38:33 +02:00
|
|
|
if (*endp && *endp != comma)
|
2007-04-08 10:28:00 +02:00
|
|
|
return -1;
|
2008-07-09 23:38:33 +02:00
|
|
|
if (ul > INT_MAX)
|
2007-04-08 10:28:00 +02:00
|
|
|
return -1;
|
2008-07-09 23:38:33 +02:00
|
|
|
ret = *arg == endp ? defval : (int)ul;
|
|
|
|
*arg = *endp ? endp + 1 : endp;
|
2007-04-08 10:28:00 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char wrap_arg_usage[] = "-w[<width>[,<indent1>[,<indent2>]]]";
|
|
|
|
#define DEFAULT_WRAPLEN 76
|
|
|
|
#define DEFAULT_INDENT1 6
|
|
|
|
#define DEFAULT_INDENT2 9
|
|
|
|
|
2008-07-09 23:38:33 +02:00
|
|
|
static int parse_wrap_args(const struct option *opt, const char *arg, int unset)
|
2007-04-08 10:28:00 +02:00
|
|
|
{
|
2008-07-09 23:38:33 +02:00
|
|
|
struct shortlog *log = opt->value;
|
|
|
|
|
|
|
|
log->wrap_lines = !unset;
|
|
|
|
if (unset)
|
|
|
|
return 0;
|
|
|
|
if (!arg) {
|
|
|
|
log->wrap = DEFAULT_WRAPLEN;
|
|
|
|
log->in1 = DEFAULT_INDENT1;
|
|
|
|
log->in2 = DEFAULT_INDENT2;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
log->wrap = parse_uint(&arg, ',', DEFAULT_WRAPLEN);
|
|
|
|
log->in1 = parse_uint(&arg, ',', DEFAULT_INDENT1);
|
|
|
|
log->in2 = parse_uint(&arg, '\0', DEFAULT_INDENT2);
|
|
|
|
if (log->wrap < 0 || log->in1 < 0 || log->in2 < 0)
|
|
|
|
return error(wrap_arg_usage);
|
|
|
|
if (log->wrap &&
|
|
|
|
((log->in1 && log->wrap <= log->in1) ||
|
|
|
|
(log->in2 && log->wrap <= log->in2)))
|
|
|
|
return error(wrap_arg_usage);
|
|
|
|
return 0;
|
2007-04-08 10:28:00 +02:00
|
|
|
}
|
|
|
|
|
2008-02-26 00:24:14 +01:00
|
|
|
void shortlog_init(struct shortlog *log)
|
|
|
|
{
|
|
|
|
memset(log, 0, sizeof(*log));
|
|
|
|
|
2009-02-08 15:34:27 +01:00
|
|
|
read_mailmap(&log->mailmap, &log->common_repo_prefix);
|
2008-02-26 00:24:14 +01:00
|
|
|
|
2008-07-21 20:03:49 +02:00
|
|
|
log->list.strdup_strings = 1;
|
2008-02-26 00:24:14 +01:00
|
|
|
log->wrap = DEFAULT_WRAPLEN;
|
|
|
|
log->in1 = DEFAULT_INDENT1;
|
|
|
|
log->in2 = DEFAULT_INDENT2;
|
|
|
|
}
|
|
|
|
|
2006-10-22 13:23:31 +02:00
|
|
|
int cmd_shortlog(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2008-07-09 23:38:33 +02:00
|
|
|
static struct shortlog log;
|
|
|
|
static struct rev_info rev;
|
2010-08-06 05:01:37 +02:00
|
|
|
int nongit = !startup_info->have_repository;
|
2008-02-26 00:24:14 +01:00
|
|
|
|
2008-07-09 23:38:33 +02:00
|
|
|
static const struct option options[] = {
|
2013-08-03 13:51:19 +02:00
|
|
|
OPT_BOOL('n', "numbered", &log.sort_by_number,
|
|
|
|
N_("sort output according to the number of commits per author")),
|
|
|
|
OPT_BOOL('s', "summary", &log.summary,
|
|
|
|
N_("Suppress commit descriptions, only provides commit count")),
|
|
|
|
OPT_BOOL('e', "email", &log.email,
|
|
|
|
N_("Show the email address of each author")),
|
2012-08-20 14:32:43 +02:00
|
|
|
{ OPTION_CALLBACK, 'w', NULL, &log, N_("w[,i1[,i2]]"),
|
|
|
|
N_("Linewrap output"), PARSE_OPT_OPTARG, &parse_wrap_args },
|
2008-07-09 23:38:33 +02:00
|
|
|
OPT_END(),
|
|
|
|
};
|
|
|
|
|
|
|
|
struct parse_opt_ctx_t ctx;
|
|
|
|
|
2009-02-08 15:34:27 +01:00
|
|
|
git_config(git_default_config, NULL);
|
2008-02-26 00:24:14 +01:00
|
|
|
shortlog_init(&log);
|
2008-07-09 23:38:33 +02:00
|
|
|
init_revisions(&rev, prefix);
|
2010-12-06 08:57:42 +01:00
|
|
|
parse_options_start(&ctx, argc, argv, prefix, options,
|
|
|
|
PARSE_OPT_KEEP_DASHDASH | PARSE_OPT_KEEP_ARGV0);
|
2008-07-09 23:38:33 +02:00
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
switch (parse_options_step(&ctx, options, shortlog_usage)) {
|
|
|
|
case PARSE_OPT_HELP:
|
|
|
|
exit(129);
|
|
|
|
case PARSE_OPT_DONE:
|
|
|
|
goto parse_done;
|
2007-04-08 10:28:00 +02:00
|
|
|
}
|
2008-07-09 23:38:34 +02:00
|
|
|
parse_revision_opt(&rev, &ctx, options, shortlog_usage);
|
2008-07-09 23:38:33 +02:00
|
|
|
}
|
|
|
|
parse_done:
|
|
|
|
argc = parse_options_end(&ctx);
|
|
|
|
|
|
|
|
if (setup_revisions(argc, argv, &rev, NULL) != 1) {
|
2011-02-23 00:42:32 +01:00
|
|
|
error(_("unrecognized argument: %s"), argv[1]);
|
2008-07-09 23:38:33 +02:00
|
|
|
usage_with_options(shortlog_usage, options);
|
2006-10-22 13:23:31 +02:00
|
|
|
}
|
|
|
|
|
2008-07-14 20:08:52 +02:00
|
|
|
log.user_format = rev.commit_format == CMIT_FMT_USERFORMAT;
|
2010-05-04 05:18:57 +02:00
|
|
|
log.abbrev = rev.abbrev;
|
2016-06-22 17:02:07 +02:00
|
|
|
log.file = rev.diffopt.file;
|
2008-07-14 20:08:52 +02:00
|
|
|
|
2007-12-11 19:09:04 +01:00
|
|
|
/* assume HEAD if from a tty */
|
2008-03-14 22:35:24 +01:00
|
|
|
if (!nongit && !rev.pending.nr && isatty(0))
|
2007-12-11 19:09:04 +01:00
|
|
|
add_head_to_pending(&rev);
|
2007-03-08 11:12:06 +01:00
|
|
|
if (rev.pending.nr == 0) {
|
2010-02-24 21:49:03 +01:00
|
|
|
if (isatty(0))
|
2011-02-23 00:42:32 +01:00
|
|
|
fprintf(stderr, _("(reading log message from standard input)\n"));
|
2008-02-26 00:24:14 +01:00
|
|
|
read_from_stdin(&log);
|
2007-03-08 11:12:06 +01:00
|
|
|
}
|
2006-10-22 13:23:31 +02:00
|
|
|
else
|
2008-02-26 00:24:14 +01:00
|
|
|
get_from_rev(&rev, &log);
|
2006-10-22 13:23:31 +02:00
|
|
|
|
2008-02-26 00:24:14 +01:00
|
|
|
shortlog_output(&log);
|
2016-06-22 17:02:07 +02:00
|
|
|
if (log.file != stdout)
|
|
|
|
fclose(log.file);
|
2008-02-26 00:24:14 +01:00
|
|
|
return 0;
|
|
|
|
}
|
2006-10-22 13:23:31 +02:00
|
|
|
|
2010-02-19 23:15:01 +01:00
|
|
|
static void add_wrapped_shortlog_msg(struct strbuf *sb, const char *s,
|
|
|
|
const struct shortlog *log)
|
|
|
|
{
|
2012-12-11 06:59:21 +01:00
|
|
|
strbuf_add_wrapped_text(sb, s, log->in1, log->in2, log->wrap);
|
|
|
|
strbuf_addch(sb, '\n');
|
2010-02-19 23:15:01 +01:00
|
|
|
}
|
|
|
|
|
2008-02-26 00:24:14 +01:00
|
|
|
void shortlog_output(struct shortlog *log)
|
|
|
|
{
|
|
|
|
int i, j;
|
2010-02-19 23:15:01 +01:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
|
2008-02-26 00:24:14 +01:00
|
|
|
if (log->sort_by_number)
|
2008-07-21 20:03:49 +02:00
|
|
|
qsort(log->list.items, log->list.nr, sizeof(struct string_list_item),
|
2016-01-18 21:02:59 +01:00
|
|
|
log->summary ? compare_by_counter : compare_by_list);
|
2008-02-26 00:24:14 +01:00
|
|
|
for (i = 0; i < log->list.nr; i++) {
|
2016-01-18 21:02:59 +01:00
|
|
|
const struct string_list_item *item = &log->list.items[i];
|
2008-02-26 00:24:14 +01:00
|
|
|
if (log->summary) {
|
2016-06-22 17:01:49 +02:00
|
|
|
fprintf(log->file, "%6d\t%s\n",
|
|
|
|
(int)UTIL_TO_INT(item), item->string);
|
2006-11-21 21:49:45 +01:00
|
|
|
} else {
|
2016-01-18 21:02:59 +01:00
|
|
|
struct string_list *onelines = item->util;
|
2016-06-22 17:01:49 +02:00
|
|
|
fprintf(log->file, "%s (%d):\n",
|
|
|
|
item->string, onelines->nr);
|
2006-12-22 22:15:59 +01:00
|
|
|
for (j = onelines->nr - 1; j >= 0; j--) {
|
2008-07-21 20:03:49 +02:00
|
|
|
const char *msg = onelines->items[j].string;
|
2007-04-08 10:28:00 +02:00
|
|
|
|
2008-02-26 00:24:14 +01:00
|
|
|
if (log->wrap_lines) {
|
2010-02-19 23:15:01 +01:00
|
|
|
strbuf_reset(&sb);
|
|
|
|
add_wrapped_shortlog_msg(&sb, msg, log);
|
2016-06-22 17:01:49 +02:00
|
|
|
fwrite(sb.buf, sb.len, 1, log->file);
|
2007-04-08 10:28:00 +02:00
|
|
|
}
|
|
|
|
else
|
2016-06-22 17:01:49 +02:00
|
|
|
fprintf(log->file, " %s\n", msg);
|
2006-12-22 22:15:59 +01:00
|
|
|
}
|
2016-06-22 17:01:49 +02:00
|
|
|
putc('\n', log->file);
|
2016-01-18 21:02:59 +01:00
|
|
|
onelines->strdup_strings = 1;
|
|
|
|
string_list_clear(onelines, 0);
|
|
|
|
free(onelines);
|
2006-10-22 13:23:31 +02:00
|
|
|
}
|
|
|
|
|
2008-02-26 00:24:14 +01:00
|
|
|
log->list.items[i].util = NULL;
|
2006-10-22 13:23:31 +02:00
|
|
|
}
|
|
|
|
|
2010-02-19 23:15:01 +01:00
|
|
|
strbuf_release(&sb);
|
2008-07-21 20:03:49 +02:00
|
|
|
log->list.strdup_strings = 1;
|
|
|
|
string_list_clear(&log->list, 1);
|
2009-02-08 15:34:30 +01:00
|
|
|
clear_mailmap(&log->mailmap);
|
2006-10-22 13:23:31 +02:00
|
|
|
}
|