2006-08-02 21:52:00 +00:00
|
|
|
#include "builtin.h"
|
2006-07-03 15:18:43 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "revision.h"
|
|
|
|
#include "tag.h"
|
2010-03-24 07:16:03 +00:00
|
|
|
#include "string-list.h"
|
2006-07-03 15:18:43 +00:00
|
|
|
|
2008-10-02 12:59:18 +00:00
|
|
|
static const char * const fmt_merge_msg_usage[] = {
|
|
|
|
"git fmt-merge-msg [--log|--no-log] [--file <file>]",
|
|
|
|
NULL
|
|
|
|
};
|
2006-07-03 15:18:43 +00:00
|
|
|
|
2006-08-15 17:23:48 +00:00
|
|
|
static int merge_summary;
|
2006-07-03 15:18:43 +00:00
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
static int fmt_merge_msg_config(const char *key, const char *value, void *cb)
|
2006-07-03 15:18:43 +00:00
|
|
|
{
|
2008-04-06 01:23:45 +00:00
|
|
|
static int found_merge_log = 0;
|
|
|
|
if (!strcmp("merge.log", key)) {
|
|
|
|
found_merge_log = 1;
|
|
|
|
merge_summary = git_config_bool(key, value);
|
|
|
|
}
|
|
|
|
if (!found_merge_log && !strcmp("merge.summary", key))
|
2006-07-03 15:18:43 +00:00
|
|
|
merge_summary = git_config_bool(key, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-24 07:16:03 +00:00
|
|
|
struct src_data {
|
|
|
|
struct string_list branch, tag, r_branch, generic;
|
|
|
|
int head_status;
|
2006-07-03 15:18:43 +00:00
|
|
|
};
|
|
|
|
|
2010-03-24 07:16:03 +00:00
|
|
|
void init_src_data(struct src_data *data)
|
2006-07-03 15:18:43 +00:00
|
|
|
{
|
2010-03-24 07:16:03 +00:00
|
|
|
data->branch.strdup_strings = 1;
|
|
|
|
data->tag.strdup_strings = 1;
|
|
|
|
data->r_branch.strdup_strings = 1;
|
|
|
|
data->generic.strdup_strings = 1;
|
2006-07-03 15:18:43 +00:00
|
|
|
}
|
|
|
|
|
2010-03-24 07:16:03 +00:00
|
|
|
static struct string_list srcs = { NULL, 0, 0, 1 };
|
|
|
|
static struct string_list origins = { NULL, 0, 0, 1 };
|
2006-07-03 15:18:43 +00:00
|
|
|
|
|
|
|
static int handle_line(char *line)
|
|
|
|
{
|
|
|
|
int i, len = strlen(line);
|
|
|
|
unsigned char *sha1;
|
|
|
|
char *src, *origin;
|
|
|
|
struct src_data *src_data;
|
2010-03-24 07:16:03 +00:00
|
|
|
struct string_list_item *item;
|
2006-07-13 05:21:05 +00:00
|
|
|
int pulling_head = 0;
|
2006-07-03 15:18:43 +00:00
|
|
|
|
|
|
|
if (len < 43 || line[40] != '\t')
|
|
|
|
return 1;
|
|
|
|
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
if (!prefixcmp(line + 41, "not-for-merge"))
|
2006-07-03 15:18:43 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (line[41] != '\t')
|
|
|
|
return 2;
|
|
|
|
|
|
|
|
line[40] = 0;
|
|
|
|
sha1 = xmalloc(20);
|
|
|
|
i = get_sha1(line, sha1);
|
|
|
|
line[40] = '\t';
|
|
|
|
if (i)
|
|
|
|
return 3;
|
|
|
|
|
|
|
|
if (line[len - 1] == '\n')
|
|
|
|
line[len - 1] = 0;
|
|
|
|
line += 42;
|
|
|
|
|
|
|
|
src = strstr(line, " of ");
|
|
|
|
if (src) {
|
|
|
|
*src = 0;
|
|
|
|
src += 4;
|
2006-07-13 05:21:05 +00:00
|
|
|
pulling_head = 0;
|
|
|
|
} else {
|
|
|
|
src = line;
|
|
|
|
pulling_head = 1;
|
|
|
|
}
|
2006-07-03 15:18:43 +00:00
|
|
|
|
2010-03-24 07:16:03 +00:00
|
|
|
item = unsorted_string_list_lookup(&srcs, src);
|
|
|
|
if (!item) {
|
|
|
|
item = string_list_append(src, &srcs);
|
|
|
|
item->util = xcalloc(1, sizeof(struct src_data));
|
|
|
|
init_src_data(item->util);
|
2006-07-03 15:18:43 +00:00
|
|
|
}
|
2010-03-24 07:16:03 +00:00
|
|
|
src_data = item->util;
|
2006-07-03 15:18:43 +00:00
|
|
|
|
2006-07-13 05:21:05 +00:00
|
|
|
if (pulling_head) {
|
2010-03-24 07:16:03 +00:00
|
|
|
origin = src;
|
2006-07-13 05:21:05 +00:00
|
|
|
src_data->head_status |= 1;
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
} else if (!prefixcmp(line, "branch ")) {
|
2010-03-24 07:16:03 +00:00
|
|
|
origin = line + 7;
|
|
|
|
string_list_append(origin, &src_data->branch);
|
2006-07-03 15:18:43 +00:00
|
|
|
src_data->head_status |= 2;
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
} else if (!prefixcmp(line, "tag ")) {
|
2006-07-03 15:18:43 +00:00
|
|
|
origin = line;
|
2010-03-24 07:16:03 +00:00
|
|
|
string_list_append(origin + 4, &src_data->tag);
|
2006-07-03 15:18:43 +00:00
|
|
|
src_data->head_status |= 2;
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
} else if (!prefixcmp(line, "remote branch ")) {
|
2010-03-24 07:16:03 +00:00
|
|
|
origin = line + 14;
|
|
|
|
string_list_append(origin, &src_data->r_branch);
|
2006-07-03 15:18:43 +00:00
|
|
|
src_data->head_status |= 2;
|
|
|
|
} else {
|
2010-03-24 07:16:03 +00:00
|
|
|
origin = src;
|
|
|
|
string_list_append(line, &src_data->generic);
|
2006-07-03 15:18:43 +00:00
|
|
|
src_data->head_status |= 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp(".", src) || !strcmp(src, origin)) {
|
|
|
|
int len = strlen(origin);
|
2010-03-24 07:16:03 +00:00
|
|
|
if (origin[0] == '\'' && origin[len - 1] == '\'')
|
2007-09-15 22:32:36 +00:00
|
|
|
origin = xmemdupz(origin + 1, len - 2);
|
2006-07-03 15:18:43 +00:00
|
|
|
} else {
|
2006-08-31 22:32:39 +00:00
|
|
|
char *new_origin = xmalloc(strlen(origin) + strlen(src) + 5);
|
2006-07-03 15:18:43 +00:00
|
|
|
sprintf(new_origin, "%s of %s", origin, src);
|
|
|
|
origin = new_origin;
|
|
|
|
}
|
2010-03-24 07:16:03 +00:00
|
|
|
string_list_append(origin, &origins)->util = sha1;
|
2006-07-03 15:18:43 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void print_joined(const char *singular, const char *plural,
|
2010-03-24 07:16:03 +00:00
|
|
|
struct string_list *list, struct strbuf *out)
|
2006-07-03 15:18:43 +00:00
|
|
|
{
|
|
|
|
if (list->nr == 0)
|
|
|
|
return;
|
|
|
|
if (list->nr == 1) {
|
2010-03-24 07:16:03 +00:00
|
|
|
strbuf_addf(out, "%s%s", singular, list->items[0].string);
|
2006-07-03 15:18:43 +00:00
|
|
|
} else {
|
|
|
|
int i;
|
2008-06-27 16:21:59 +00:00
|
|
|
strbuf_addstr(out, plural);
|
2006-07-03 15:18:43 +00:00
|
|
|
for (i = 0; i < list->nr - 1; i++)
|
2010-03-24 07:16:03 +00:00
|
|
|
strbuf_addf(out, "%s%s", i > 0 ? ", " : "",
|
|
|
|
list->items[i].string);
|
|
|
|
strbuf_addf(out, " and %s", list->items[list->nr - 1].string);
|
2006-07-03 15:18:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void shortlog(const char *name, unsigned char *sha1,
|
2008-06-27 16:21:59 +00:00
|
|
|
struct commit *head, struct rev_info *rev, int limit,
|
|
|
|
struct strbuf *out)
|
2006-07-03 15:18:43 +00:00
|
|
|
{
|
|
|
|
int i, count = 0;
|
|
|
|
struct commit *commit;
|
|
|
|
struct object *branch;
|
2010-03-24 07:16:03 +00:00
|
|
|
struct string_list subjects = { NULL, 0, 0, 1 };
|
2007-11-13 07:16:08 +00:00
|
|
|
int flags = UNINTERESTING | TREESAME | SEEN | SHOWN | ADDED;
|
2010-03-24 07:16:01 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2006-07-03 15:18:43 +00:00
|
|
|
|
|
|
|
branch = deref_tag(parse_object(sha1), sha1_to_hex(sha1), 40);
|
2006-07-12 03:45:31 +00:00
|
|
|
if (!branch || branch->type != OBJ_COMMIT)
|
2006-07-03 15:18:43 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
setup_revisions(0, NULL, rev, NULL);
|
|
|
|
rev->ignore_merges = 1;
|
|
|
|
add_pending_object(rev, branch, name);
|
|
|
|
add_pending_object(rev, &head->object, "^HEAD");
|
|
|
|
head->object.flags |= UNINTERESTING;
|
2008-02-18 07:31:56 +00:00
|
|
|
if (prepare_revision_walk(rev))
|
|
|
|
die("revision walk setup failed");
|
2006-07-03 15:18:43 +00:00
|
|
|
while ((commit = get_revision(rev)) != NULL) {
|
2010-03-24 07:16:01 +00:00
|
|
|
struct pretty_print_context ctx = {0};
|
2006-07-03 15:18:43 +00:00
|
|
|
|
|
|
|
/* ignore merges */
|
|
|
|
if (commit->parents && commit->parents->next)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
count++;
|
|
|
|
if (subjects.nr > limit)
|
|
|
|
continue;
|
|
|
|
|
2010-03-24 07:16:01 +00:00
|
|
|
format_commit_message(commit, "%s", &sb, &ctx);
|
|
|
|
strbuf_ltrim(&sb);
|
2008-04-15 18:01:36 +00:00
|
|
|
|
2010-03-24 07:16:01 +00:00
|
|
|
if (!sb.len)
|
2010-03-24 07:16:03 +00:00
|
|
|
string_list_append(sha1_to_hex(commit->object.sha1),
|
|
|
|
&subjects);
|
2010-03-24 07:16:01 +00:00
|
|
|
else
|
2010-03-24 07:16:03 +00:00
|
|
|
string_list_append(strbuf_detach(&sb, NULL), &subjects);
|
2006-07-03 15:18:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (count > limit)
|
2008-06-27 16:21:59 +00:00
|
|
|
strbuf_addf(out, "\n* %s: (%d commits)\n", name, count);
|
2006-07-03 15:18:43 +00:00
|
|
|
else
|
2008-06-27 16:21:59 +00:00
|
|
|
strbuf_addf(out, "\n* %s:\n", name);
|
2006-07-03 15:18:43 +00:00
|
|
|
|
|
|
|
for (i = 0; i < subjects.nr; i++)
|
|
|
|
if (i >= limit)
|
2008-06-27 16:21:59 +00:00
|
|
|
strbuf_addf(out, " ...\n");
|
2006-07-03 15:18:43 +00:00
|
|
|
else
|
2010-03-24 07:16:03 +00:00
|
|
|
strbuf_addf(out, " %s\n", subjects.items[i].string);
|
2006-07-03 15:18:43 +00:00
|
|
|
|
|
|
|
clear_commit_marks((struct commit *)branch, flags);
|
|
|
|
clear_commit_marks(head, flags);
|
|
|
|
free_commit_list(rev->commits);
|
|
|
|
rev->commits = NULL;
|
|
|
|
rev->pending.nr = 0;
|
|
|
|
|
2010-03-24 07:16:03 +00:00
|
|
|
string_list_clear(&subjects, 0);
|
2006-07-03 15:18:43 +00:00
|
|
|
}
|
|
|
|
|
2010-05-10 17:17:50 +00:00
|
|
|
static void do_fmt_merge_msg_title(struct strbuf *out,
|
|
|
|
const char *current_branch) {
|
|
|
|
int i = 0;
|
2009-03-07 20:02:26 +00:00
|
|
|
char *sep = "";
|
2010-03-24 07:15:58 +00:00
|
|
|
|
2008-06-27 16:21:59 +00:00
|
|
|
strbuf_addstr(out, "Merge ");
|
2006-07-03 15:18:43 +00:00
|
|
|
for (i = 0; i < srcs.nr; i++) {
|
2010-03-24 07:16:03 +00:00
|
|
|
struct src_data *src_data = srcs.items[i].util;
|
2006-07-03 15:18:43 +00:00
|
|
|
const char *subsep = "";
|
|
|
|
|
2008-06-27 16:21:59 +00:00
|
|
|
strbuf_addstr(out, sep);
|
2006-07-03 15:18:43 +00:00
|
|
|
sep = "; ";
|
|
|
|
|
|
|
|
if (src_data->head_status == 1) {
|
2010-03-24 07:16:03 +00:00
|
|
|
strbuf_addstr(out, srcs.items[i].string);
|
2006-07-03 15:18:43 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (src_data->head_status == 3) {
|
|
|
|
subsep = ", ";
|
2008-06-27 16:21:59 +00:00
|
|
|
strbuf_addstr(out, "HEAD");
|
2006-07-03 15:18:43 +00:00
|
|
|
}
|
|
|
|
if (src_data->branch.nr) {
|
2008-06-27 16:21:59 +00:00
|
|
|
strbuf_addstr(out, subsep);
|
2006-07-03 15:18:43 +00:00
|
|
|
subsep = ", ";
|
2008-06-27 16:21:59 +00:00
|
|
|
print_joined("branch ", "branches ", &src_data->branch,
|
|
|
|
out);
|
2006-07-03 15:18:43 +00:00
|
|
|
}
|
|
|
|
if (src_data->r_branch.nr) {
|
2008-06-27 16:21:59 +00:00
|
|
|
strbuf_addstr(out, subsep);
|
2006-07-03 15:18:43 +00:00
|
|
|
subsep = ", ";
|
|
|
|
print_joined("remote branch ", "remote branches ",
|
2008-06-27 16:21:59 +00:00
|
|
|
&src_data->r_branch, out);
|
2006-07-03 15:18:43 +00:00
|
|
|
}
|
|
|
|
if (src_data->tag.nr) {
|
2008-06-27 16:21:59 +00:00
|
|
|
strbuf_addstr(out, subsep);
|
2006-07-03 15:18:43 +00:00
|
|
|
subsep = ", ";
|
2008-06-27 16:21:59 +00:00
|
|
|
print_joined("tag ", "tags ", &src_data->tag, out);
|
2006-07-03 15:18:43 +00:00
|
|
|
}
|
|
|
|
if (src_data->generic.nr) {
|
2008-06-27 16:21:59 +00:00
|
|
|
strbuf_addstr(out, subsep);
|
|
|
|
print_joined("commit ", "commits ", &src_data->generic,
|
|
|
|
out);
|
2006-07-03 15:18:43 +00:00
|
|
|
}
|
2010-03-24 07:16:03 +00:00
|
|
|
if (strcmp(".", srcs.items[i].string))
|
|
|
|
strbuf_addf(out, " of %s", srcs.items[i].string);
|
2006-07-03 15:18:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!strcmp("master", current_branch))
|
2008-06-27 16:21:59 +00:00
|
|
|
strbuf_addch(out, '\n');
|
2006-07-03 15:18:43 +00:00
|
|
|
else
|
2008-06-27 16:21:59 +00:00
|
|
|
strbuf_addf(out, " into %s\n", current_branch);
|
2010-05-10 17:17:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int do_fmt_merge_msg(int merge_summary, struct strbuf *in,
|
|
|
|
struct strbuf *out) {
|
|
|
|
int limit = 20, i = 0, pos = 0;
|
|
|
|
unsigned char head_sha1[20];
|
|
|
|
const char *current_branch;
|
|
|
|
|
|
|
|
/* get current branch */
|
|
|
|
current_branch = resolve_ref("HEAD", head_sha1, 1, NULL);
|
|
|
|
if (!current_branch)
|
|
|
|
die("No current branch");
|
|
|
|
if (!prefixcmp(current_branch, "refs/heads/"))
|
|
|
|
current_branch += 11;
|
|
|
|
|
|
|
|
/* get a line */
|
|
|
|
while (pos < in->len) {
|
|
|
|
int len;
|
|
|
|
char *newline, *p = in->buf + pos;
|
|
|
|
|
|
|
|
newline = strchr(p, '\n');
|
|
|
|
len = newline ? newline - p : strlen(p);
|
|
|
|
pos += len + !!newline;
|
|
|
|
i++;
|
|
|
|
p[len] = 0;
|
|
|
|
if (handle_line(p))
|
|
|
|
die ("Error in line %d: %.*s", i, len, p);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!srcs.nr)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
do_fmt_merge_msg_title(out, current_branch);
|
2006-07-03 15:18:43 +00:00
|
|
|
|
|
|
|
if (merge_summary) {
|
|
|
|
struct commit *head;
|
|
|
|
struct rev_info rev;
|
|
|
|
|
|
|
|
head = lookup_commit(head_sha1);
|
2008-06-27 16:21:59 +00:00
|
|
|
init_revisions(&rev, NULL);
|
2006-07-03 15:18:43 +00:00
|
|
|
rev.commit_format = CMIT_FMT_ONELINE;
|
|
|
|
rev.ignore_merges = 1;
|
|
|
|
rev.limited = 1;
|
|
|
|
|
|
|
|
for (i = 0; i < origins.nr; i++)
|
2010-03-24 07:16:03 +00:00
|
|
|
shortlog(origins.items[i].string, origins.items[i].util,
|
2008-06-27 16:21:59 +00:00
|
|
|
head, &rev, limit, out);
|
2006-07-03 15:18:43 +00:00
|
|
|
}
|
2008-06-27 16:21:59 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-10 17:17:49 +00:00
|
|
|
int fmt_merge_msg(int merge_summary, struct strbuf *in, struct strbuf *out) {
|
|
|
|
return do_fmt_merge_msg(merge_summary, in, out);
|
|
|
|
}
|
|
|
|
|
2008-06-27 16:21:59 +00:00
|
|
|
int cmd_fmt_merge_msg(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2008-10-02 12:59:18 +00:00
|
|
|
const char *inpath = NULL;
|
|
|
|
struct option options[] = {
|
|
|
|
OPT_BOOLEAN(0, "log", &merge_summary, "populate log with the shortlog"),
|
2010-03-24 07:16:04 +00:00
|
|
|
{ OPTION_BOOLEAN, 0, "summary", &merge_summary, NULL,
|
|
|
|
"alias for --log (deprecated)",
|
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
|
2009-05-23 18:53:13 +00:00
|
|
|
OPT_FILENAME('F', "file", &inpath, "file to read from"),
|
2008-10-02 12:59:18 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
2008-06-27 16:21:59 +00:00
|
|
|
FILE *in = stdin;
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf input = STRBUF_INIT, output = STRBUF_INIT;
|
2008-06-27 16:21:59 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
git_config(fmt_merge_msg_config, NULL);
|
2009-05-23 18:53:12 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, options, fmt_merge_msg_usage,
|
|
|
|
0);
|
2008-10-02 12:59:18 +00:00
|
|
|
if (argc > 0)
|
|
|
|
usage_with_options(fmt_merge_msg_usage, options);
|
|
|
|
|
|
|
|
if (inpath && strcmp(inpath, "-")) {
|
|
|
|
in = fopen(inpath, "r");
|
|
|
|
if (!in)
|
2009-06-27 15:58:47 +00:00
|
|
|
die_errno("cannot open '%s'", inpath);
|
2008-06-27 16:21:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (strbuf_read(&input, fileno(in), 0) < 0)
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("could not read input file");
|
2008-06-27 16:21:59 +00:00
|
|
|
ret = fmt_merge_msg(merge_summary, &input, &output);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-10-02 12:59:18 +00:00
|
|
|
write_in_full(STDOUT_FILENO, output.buf, output.len);
|
2006-07-03 15:18:43 +00:00
|
|
|
return 0;
|
|
|
|
}
|