2006-04-21 19:27:34 +02:00
|
|
|
/*
|
|
|
|
* Builtin "git log" and related commands (show, whatchanged)
|
|
|
|
*
|
|
|
|
* (C) Copyright 2006 Linus Torvalds
|
|
|
|
* 2006 Junio Hamano
|
|
|
|
*/
|
|
|
|
#include "cache.h"
|
2008-02-18 08:26:03 +01:00
|
|
|
#include "color.h"
|
2006-04-21 19:27:34 +02:00
|
|
|
#include "commit.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "revision.h"
|
|
|
|
#include "log-tree.h"
|
2006-04-21 22:19:58 +02:00
|
|
|
#include "builtin.h"
|
2006-12-14 11:31:05 +01:00
|
|
|
#include "tag.h"
|
2007-02-08 18:51:56 +01:00
|
|
|
#include "reflog-walk.h"
|
2007-04-10 02:01:27 +02:00
|
|
|
#include "patch-ids.h"
|
2007-04-17 01:05:10 +02:00
|
|
|
#include "refs.h"
|
2008-02-19 04:56:13 +01:00
|
|
|
#include "run-command.h"
|
2008-02-26 00:24:17 +01:00
|
|
|
#include "shortlog.h"
|
2006-04-21 19:27:34 +02:00
|
|
|
|
2006-11-23 10:36:33 +01:00
|
|
|
static int default_show_root = 1;
|
2007-07-04 12:37:27 +02:00
|
|
|
static const char *fmt_patch_subject_prefix = "PATCH";
|
2008-03-02 10:05:53 +01:00
|
|
|
static const char *fmt_pretty;
|
2006-11-23 10:36:33 +01:00
|
|
|
|
2007-04-17 01:05:10 +02:00
|
|
|
static void add_name_decoration(const char *prefix, const char *name, struct object *obj)
|
|
|
|
{
|
|
|
|
int plen = strlen(prefix);
|
|
|
|
int nlen = strlen(name);
|
|
|
|
struct name_decoration *res = xmalloc(sizeof(struct name_decoration) + plen + nlen);
|
|
|
|
memcpy(res->name, prefix, plen);
|
|
|
|
memcpy(res->name + plen, name, nlen + 1);
|
|
|
|
res->next = add_decoration(&name_decoration, obj, res);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int add_ref_decoration(const char *refname, const unsigned char *sha1, int flags, void *cb_data)
|
|
|
|
{
|
|
|
|
struct object *obj = parse_object(sha1);
|
|
|
|
if (!obj)
|
|
|
|
return 0;
|
|
|
|
add_name_decoration("", refname, obj);
|
|
|
|
while (obj->type == OBJ_TAG) {
|
|
|
|
obj = ((struct tag *)obj)->tagged;
|
|
|
|
if (!obj)
|
|
|
|
break;
|
|
|
|
add_name_decoration("tag: ", refname, obj);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-29 07:44:25 +02:00
|
|
|
static void cmd_log_init(int argc, const char **argv, const char *prefix,
|
2006-04-21 19:27:34 +02:00
|
|
|
struct rev_info *rev)
|
|
|
|
{
|
2006-12-25 20:48:35 +01:00
|
|
|
int i;
|
2007-04-17 01:05:10 +02:00
|
|
|
int decorate = 0;
|
2006-12-25 20:48:35 +01:00
|
|
|
|
2006-04-21 19:27:34 +02:00
|
|
|
rev->abbrev = DEFAULT_ABBREV;
|
|
|
|
rev->commit_format = CMIT_FMT_DEFAULT;
|
2008-03-02 10:05:53 +01:00
|
|
|
if (fmt_pretty)
|
2008-04-08 02:11:34 +02:00
|
|
|
get_commit_format(fmt_pretty, rev);
|
2006-04-21 19:27:34 +02:00
|
|
|
rev->verbose_header = 1;
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(&rev->diffopt, RECURSIVE);
|
2006-11-23 10:36:33 +01:00
|
|
|
rev->show_root_diff = default_show_root;
|
2007-07-04 12:37:27 +02:00
|
|
|
rev->subject_prefix = fmt_patch_subject_prefix;
|
2006-04-21 19:27:34 +02:00
|
|
|
argc = setup_revisions(argc, argv, rev, "HEAD");
|
2006-06-25 14:39:35 +02:00
|
|
|
if (rev->diffopt.pickaxe || rev->diffopt.filter)
|
|
|
|
rev->always_show_header = 0;
|
2007-11-10 20:05:14 +01:00
|
|
|
if (DIFF_OPT_TST(&rev->diffopt, FOLLOW_RENAMES)) {
|
Finally implement "git log --follow"
Ok, I've really held off doing this too damn long, because I'm lazy, and I
was always hoping that somebody else would do it.
But no, people keep asking for it, but nobody actually did anything, so I
decided I might as well bite the bullet, and instead of telling people
they could add a "--follow" flag to "git log" to do what they want to do,
I decided that it looks like I just have to do it for them..
The code wasn't actually that complicated, in that the diffstat for this
patch literally says "70 insertions(+), 1 deletions(-)", but I will have
to admit that in order to get to this fairly simple patch, you did have to
know and understand the internal git diff generation machinery pretty
well, and had to really be able to follow how commit generation interacts
with generating patches and generating the log.
So I suspect that while I was right that it wasn't that hard, I might have
been expecting too much of random people - this patch does seem to be
firmly in the core "Linus or Junio" territory.
To make a long story short: I'm sorry for it taking so long until I just
did it.
I'm not going to guarantee that this works for everybody, but you really
can just look at the patch, and after the appropriate appreciative noises
("Ooh, aah") over how clever I am, you can then just notice that the code
itself isn't really that complicated.
All the real new code is in the new "try_to_follow_renames()" function. It
really isn't rocket science: we notice that the pathname we were looking
at went away, so we start a full tree diff and try to see if we can
instead make that pathname be a rename or a copy from some other previous
pathname. And if we can, we just continue, except we show *that*
particular diff, and ever after we use the _previous_ pathname.
One thing to look out for: the "rename detection" is considered to be a
singular event in the _linear_ "git log" output! That's what people want
to do, but I just wanted to point out that this patch is *not* carrying
around a "commit,pathname" kind of pair and it's *not* going to be able to
notice the file coming from multiple *different* files in earlier history.
IOW, if you use "git log --follow", then you get the stupid CVS/SVN kind
of "files have single identities" kind of semantics, and git log will just
pick the identity based on the normal move/copy heuristics _as_if_ the
history could be linearized.
Put another way: I think the model is broken, but given the broken model,
I think this patch does just about as well as you can do. If you have
merges with the same "file" having different filenames over the two
branches, git will just end up picking _one_ of the pathnames at the point
where the newer one goes away. It never looks at multiple pathnames in
parallel.
And if you understood all that, you probably didn't need it explained, and
if you didn't understand the above blathering, it doesn't really mtter to
you. What matters to you is that you can now do
git log -p --follow builtin-rev-list.c
and it will find the point where the old "rev-list.c" got renamed to
"builtin-rev-list.c" and show it as such.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-06-19 23:22:46 +02:00
|
|
|
rev->always_show_header = 0;
|
|
|
|
if (rev->diffopt.nr_paths != 1)
|
|
|
|
usage("git logs can only follow renames on one pathname at a time");
|
|
|
|
}
|
2006-12-25 20:48:35 +01:00
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
const char *arg = argv[i];
|
2007-05-16 13:15:07 +02:00
|
|
|
if (!strcmp(arg, "--decorate")) {
|
2007-04-17 01:05:10 +02:00
|
|
|
if (!decorate)
|
|
|
|
for_each_ref(add_ref_decoration, NULL);
|
|
|
|
decorate = 1;
|
|
|
|
} else
|
2006-12-25 20:48:35 +01:00
|
|
|
die("unrecognized argument: %s", arg);
|
|
|
|
}
|
2006-06-25 14:39:35 +02:00
|
|
|
}
|
|
|
|
|
2007-11-04 21:12:05 +01:00
|
|
|
/*
|
|
|
|
* This gives a rough estimate for how many commits we
|
|
|
|
* will print out in the list.
|
|
|
|
*/
|
|
|
|
static int estimate_commit_count(struct rev_info *rev, struct commit_list *list)
|
|
|
|
{
|
|
|
|
int n = 0;
|
|
|
|
|
|
|
|
while (list) {
|
|
|
|
struct commit *commit = list->item;
|
|
|
|
unsigned int flags = commit->object.flags;
|
|
|
|
list = list->next;
|
2007-11-13 08:16:08 +01:00
|
|
|
if (!(flags & (TREESAME | UNINTERESTING)))
|
2007-11-05 22:22:34 +01:00
|
|
|
n++;
|
2007-11-04 21:12:05 +01:00
|
|
|
}
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void show_early_header(struct rev_info *rev, const char *stage, int nr)
|
|
|
|
{
|
|
|
|
if (rev->shown_one) {
|
|
|
|
rev->shown_one = 0;
|
|
|
|
if (rev->commit_format != CMIT_FMT_ONELINE)
|
|
|
|
putchar(rev->diffopt.line_termination);
|
|
|
|
}
|
|
|
|
printf("Final output: %d %s\n", nr, stage);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct itimerval early_output_timer;
|
|
|
|
|
2007-11-03 19:11:10 +01:00
|
|
|
static void log_show_early(struct rev_info *revs, struct commit_list *list)
|
|
|
|
{
|
|
|
|
int i = revs->early_output;
|
2007-11-04 21:12:05 +01:00
|
|
|
int show_header = 1;
|
2007-11-03 19:11:10 +01:00
|
|
|
|
|
|
|
sort_in_topological_order(&list, revs->lifo);
|
|
|
|
while (list && i) {
|
|
|
|
struct commit *commit = list->item;
|
2007-11-04 21:12:05 +01:00
|
|
|
switch (simplify_commit(revs, commit)) {
|
|
|
|
case commit_show:
|
|
|
|
if (show_header) {
|
|
|
|
int n = estimate_commit_count(revs, list);
|
|
|
|
show_early_header(revs, "incomplete", n);
|
|
|
|
show_header = 0;
|
|
|
|
}
|
|
|
|
log_tree_commit(revs, commit);
|
|
|
|
i--;
|
|
|
|
break;
|
|
|
|
case commit_ignore:
|
|
|
|
break;
|
|
|
|
case commit_error:
|
|
|
|
return;
|
|
|
|
}
|
2007-11-03 19:11:10 +01:00
|
|
|
list = list->next;
|
|
|
|
}
|
2007-11-04 21:12:05 +01:00
|
|
|
|
|
|
|
/* Did we already get enough commits for the early output? */
|
|
|
|
if (!i)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ..if no, then repeat it twice a second until we
|
|
|
|
* do.
|
|
|
|
*
|
|
|
|
* NOTE! We don't use "it_interval", because if the
|
|
|
|
* reader isn't listening, we want our output to be
|
|
|
|
* throttled by the writing, and not have the timer
|
|
|
|
* trigger every second even if we're blocked on a
|
|
|
|
* reader!
|
|
|
|
*/
|
|
|
|
early_output_timer.it_value.tv_sec = 0;
|
|
|
|
early_output_timer.it_value.tv_usec = 500000;
|
|
|
|
setitimer(ITIMER_REAL, &early_output_timer, NULL);
|
2007-11-03 19:11:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void early_output(int signal)
|
|
|
|
{
|
|
|
|
show_early_output = log_show_early;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void setup_early_output(struct rev_info *rev)
|
|
|
|
{
|
|
|
|
struct sigaction sa;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up the signal handler, minimally intrusively:
|
|
|
|
* we only set a single volatile integer word (not
|
|
|
|
* using sigatomic_t - trying to avoid unnecessary
|
|
|
|
* system dependencies and headers), and using
|
|
|
|
* SA_RESTART.
|
|
|
|
*/
|
|
|
|
memset(&sa, 0, sizeof(sa));
|
|
|
|
sa.sa_handler = early_output;
|
|
|
|
sigemptyset(&sa.sa_mask);
|
|
|
|
sa.sa_flags = SA_RESTART;
|
|
|
|
sigaction(SIGALRM, &sa, NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we can get the whole output in less than a
|
|
|
|
* tenth of a second, don't even bother doing the
|
|
|
|
* early-output thing..
|
|
|
|
*
|
|
|
|
* This is a one-time-only trigger.
|
|
|
|
*/
|
2007-11-04 21:12:05 +01:00
|
|
|
early_output_timer.it_value.tv_sec = 0;
|
|
|
|
early_output_timer.it_value.tv_usec = 100000;
|
|
|
|
setitimer(ITIMER_REAL, &early_output_timer, NULL);
|
2007-11-03 19:11:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void finish_early_output(struct rev_info *rev)
|
|
|
|
{
|
2007-11-04 21:12:05 +01:00
|
|
|
int n = estimate_commit_count(rev, rev->commits);
|
2007-11-03 19:11:10 +01:00
|
|
|
signal(SIGALRM, SIG_IGN);
|
2007-11-04 21:12:05 +01:00
|
|
|
show_early_header(rev, "done", n);
|
2007-11-03 19:11:10 +01:00
|
|
|
}
|
|
|
|
|
2006-06-25 14:39:35 +02:00
|
|
|
static int cmd_log_walk(struct rev_info *rev)
|
|
|
|
{
|
|
|
|
struct commit *commit;
|
2006-04-21 19:27:34 +02:00
|
|
|
|
2007-11-03 19:11:10 +01:00
|
|
|
if (rev->early_output)
|
|
|
|
setup_early_output(rev);
|
|
|
|
|
2008-02-18 08:31:56 +01:00
|
|
|
if (prepare_revision_walk(rev))
|
|
|
|
die("revision walk setup failed");
|
2007-11-03 19:11:10 +01:00
|
|
|
|
|
|
|
if (rev->early_output)
|
|
|
|
finish_early_output(rev);
|
|
|
|
|
2006-04-21 19:27:34 +02:00
|
|
|
while ((commit = get_revision(rev)) != NULL) {
|
|
|
|
log_tree_commit(rev, commit);
|
2007-01-20 22:28:16 +01:00
|
|
|
if (!rev->reflog_info) {
|
|
|
|
/* we allow cycles in reflog ancestry */
|
|
|
|
free(commit->buffer);
|
|
|
|
commit->buffer = NULL;
|
|
|
|
}
|
2006-06-18 03:47:58 +02:00
|
|
|
free_commit_list(commit->parents);
|
|
|
|
commit->parents = NULL;
|
2006-04-21 19:27:34 +02:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-11-23 10:36:33 +01:00
|
|
|
static int git_log_config(const char *var, const char *value)
|
|
|
|
{
|
2008-03-02 10:05:53 +01:00
|
|
|
if (!strcmp(var, "format.pretty"))
|
|
|
|
return git_config_string(&fmt_pretty, var, value);
|
2007-07-04 12:37:27 +02:00
|
|
|
if (!strcmp(var, "format.subjectprefix")) {
|
|
|
|
if (!value)
|
2008-02-11 19:48:55 +01:00
|
|
|
config_error_nonbool(var);
|
2007-07-04 12:37:27 +02:00
|
|
|
fmt_patch_subject_prefix = xstrdup(value);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-11-23 10:36:33 +01:00
|
|
|
if (!strcmp(var, "log.showroot")) {
|
|
|
|
default_show_root = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return git_diff_ui_config(var, value);
|
|
|
|
}
|
|
|
|
|
2006-07-29 07:44:25 +02:00
|
|
|
int cmd_whatchanged(int argc, const char **argv, const char *prefix)
|
2006-04-21 19:27:34 +02:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
|
|
|
|
2006-11-23 10:36:33 +01:00
|
|
|
git_config(git_log_config);
|
2008-02-18 08:26:03 +01:00
|
|
|
|
|
|
|
if (diff_use_color_default == -1)
|
|
|
|
diff_use_color_default = git_use_color_default;
|
|
|
|
|
2006-07-29 06:21:48 +02:00
|
|
|
init_revisions(&rev, prefix);
|
2006-04-21 19:27:34 +02:00
|
|
|
rev.diff = 1;
|
2006-06-11 19:57:35 +02:00
|
|
|
rev.simplify_history = 0;
|
2006-07-29 07:44:25 +02:00
|
|
|
cmd_log_init(argc, argv, prefix, &rev);
|
2006-06-25 14:39:35 +02:00
|
|
|
if (!rev.diffopt.output_format)
|
|
|
|
rev.diffopt.output_format = DIFF_FORMAT_RAW;
|
|
|
|
return cmd_log_walk(&rev);
|
2006-04-21 19:27:34 +02:00
|
|
|
}
|
|
|
|
|
2007-12-18 19:01:33 +01:00
|
|
|
static void show_tagger(char *buf, int len, struct rev_info *rev)
|
|
|
|
{
|
|
|
|
char *email_end, *p;
|
|
|
|
unsigned long date;
|
|
|
|
int tz;
|
|
|
|
|
|
|
|
email_end = memchr(buf, '>', len);
|
|
|
|
if (!email_end)
|
|
|
|
return;
|
|
|
|
p = ++email_end;
|
|
|
|
while (isspace(*p))
|
|
|
|
p++;
|
|
|
|
date = strtoul(p, &p, 10);
|
|
|
|
while (isspace(*p))
|
|
|
|
p++;
|
|
|
|
tz = (int)strtol(p, NULL, 10);
|
|
|
|
printf("Tagger: %.*s\nDate: %s\n", (int)(email_end - buf), buf,
|
|
|
|
show_date(date, tz, rev->date_mode));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int show_object(const unsigned char *sha1, int show_tag_object,
|
|
|
|
struct rev_info *rev)
|
2006-12-14 11:31:05 +01:00
|
|
|
{
|
|
|
|
unsigned long size;
|
2007-02-26 20:55:59 +01:00
|
|
|
enum object_type type;
|
|
|
|
char *buf = read_sha1_file(sha1, &type, &size);
|
2006-12-14 11:31:05 +01:00
|
|
|
int offset = 0;
|
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
return error("Could not read object %s", sha1_to_hex(sha1));
|
|
|
|
|
2007-12-18 19:01:33 +01:00
|
|
|
if (show_tag_object)
|
|
|
|
while (offset < size && buf[offset] != '\n') {
|
|
|
|
int new_offset = offset + 1;
|
2006-12-14 11:31:05 +01:00
|
|
|
while (new_offset < size && buf[new_offset++] != '\n')
|
|
|
|
; /* do nothing */
|
2007-12-18 19:01:33 +01:00
|
|
|
if (!prefixcmp(buf + offset, "tagger "))
|
|
|
|
show_tagger(buf + offset + 7,
|
|
|
|
new_offset - offset - 7, rev);
|
2006-12-14 11:31:05 +01:00
|
|
|
offset = new_offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (offset < size)
|
|
|
|
fwrite(buf + offset, size - offset, 1, stdout);
|
|
|
|
free(buf);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int show_tree_object(const unsigned char *sha1,
|
|
|
|
const char *base, int baselen,
|
|
|
|
const char *pathname, unsigned mode, int stage)
|
|
|
|
{
|
|
|
|
printf("%s%s\n", pathname, S_ISDIR(mode) ? "/" : "");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-29 07:44:25 +02:00
|
|
|
int cmd_show(int argc, const char **argv, const char *prefix)
|
2006-04-21 19:27:34 +02:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
2006-12-14 11:31:05 +01:00
|
|
|
struct object_array_entry *objects;
|
|
|
|
int i, count, ret = 0;
|
2006-04-21 19:27:34 +02:00
|
|
|
|
2006-11-23 10:36:33 +01:00
|
|
|
git_config(git_log_config);
|
2008-02-18 08:26:03 +01:00
|
|
|
|
|
|
|
if (diff_use_color_default == -1)
|
|
|
|
diff_use_color_default = git_use_color_default;
|
|
|
|
|
2006-07-29 06:21:48 +02:00
|
|
|
init_revisions(&rev, prefix);
|
2006-04-21 19:27:34 +02:00
|
|
|
rev.diff = 1;
|
|
|
|
rev.combine_merges = 1;
|
|
|
|
rev.dense_combined_merges = 1;
|
|
|
|
rev.always_show_header = 1;
|
|
|
|
rev.ignore_merges = 0;
|
|
|
|
rev.no_walk = 1;
|
2006-07-29 07:44:25 +02:00
|
|
|
cmd_log_init(argc, argv, prefix, &rev);
|
2006-12-14 11:31:05 +01:00
|
|
|
|
|
|
|
count = rev.pending.nr;
|
|
|
|
objects = rev.pending.objects;
|
|
|
|
for (i = 0; i < count && !ret; i++) {
|
|
|
|
struct object *o = objects[i].item;
|
|
|
|
const char *name = objects[i].name;
|
|
|
|
switch (o->type) {
|
|
|
|
case OBJ_BLOB:
|
2007-12-18 19:01:33 +01:00
|
|
|
ret = show_object(o->sha1, 0, NULL);
|
2006-12-14 11:31:05 +01:00
|
|
|
break;
|
|
|
|
case OBJ_TAG: {
|
|
|
|
struct tag *t = (struct tag *)o;
|
|
|
|
|
2007-12-18 19:01:33 +01:00
|
|
|
printf("%stag %s%s\n",
|
2007-11-10 20:05:14 +01:00
|
|
|
diff_get_color_opt(&rev.diffopt, DIFF_COMMIT),
|
2006-12-14 11:31:05 +01:00
|
|
|
t->tag,
|
2007-11-10 20:05:14 +01:00
|
|
|
diff_get_color_opt(&rev.diffopt, DIFF_RESET));
|
2007-12-18 19:01:33 +01:00
|
|
|
ret = show_object(o->sha1, 1, &rev);
|
2006-12-14 11:31:05 +01:00
|
|
|
objects[i].item = (struct object *)t->tagged;
|
|
|
|
i--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case OBJ_TREE:
|
|
|
|
printf("%stree %s%s\n\n",
|
2007-11-10 20:05:14 +01:00
|
|
|
diff_get_color_opt(&rev.diffopt, DIFF_COMMIT),
|
2006-12-14 11:31:05 +01:00
|
|
|
name,
|
2007-11-10 20:05:14 +01:00
|
|
|
diff_get_color_opt(&rev.diffopt, DIFF_RESET));
|
2006-12-14 11:31:05 +01:00
|
|
|
read_tree_recursive((struct tree *)o, "", 0, 0, NULL,
|
|
|
|
show_tree_object);
|
|
|
|
break;
|
|
|
|
case OBJ_COMMIT:
|
|
|
|
rev.pending.nr = rev.pending.alloc = 0;
|
|
|
|
rev.pending.objects = NULL;
|
|
|
|
add_object_array(o, name, &rev.pending);
|
|
|
|
ret = cmd_log_walk(&rev);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = error("Unknown type: %d", o->type);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(objects);
|
|
|
|
return ret;
|
2006-04-21 19:27:34 +02:00
|
|
|
}
|
|
|
|
|
2007-02-08 18:51:56 +01:00
|
|
|
/*
|
|
|
|
* This is equivalent to "git log -g --abbrev-commit --pretty=oneline"
|
|
|
|
*/
|
|
|
|
int cmd_log_reflog(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
struct rev_info rev;
|
|
|
|
|
|
|
|
git_config(git_log_config);
|
2008-02-18 08:26:03 +01:00
|
|
|
|
|
|
|
if (diff_use_color_default == -1)
|
|
|
|
diff_use_color_default = git_use_color_default;
|
|
|
|
|
2007-02-08 18:51:56 +01:00
|
|
|
init_revisions(&rev, prefix);
|
|
|
|
init_reflog_walk(&rev.reflog_info);
|
|
|
|
rev.abbrev_commit = 1;
|
|
|
|
rev.verbose_header = 1;
|
|
|
|
cmd_log_init(argc, argv, prefix, &rev);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This means that we override whatever commit format the user gave
|
|
|
|
* on the cmd line. Sad, but cmd_log_init() currently doesn't
|
|
|
|
* allow us to set a different default.
|
|
|
|
*/
|
|
|
|
rev.commit_format = CMIT_FMT_ONELINE;
|
2008-04-08 02:11:34 +02:00
|
|
|
rev.use_terminator = 1;
|
2007-02-08 18:51:56 +01:00
|
|
|
rev.always_show_header = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We get called through "git reflog", so unlike the other log
|
|
|
|
* routines, we need to set up our pager manually..
|
|
|
|
*/
|
|
|
|
setup_pager();
|
|
|
|
|
|
|
|
return cmd_log_walk(&rev);
|
|
|
|
}
|
|
|
|
|
2006-07-29 07:44:25 +02:00
|
|
|
int cmd_log(int argc, const char **argv, const char *prefix)
|
2006-04-21 19:27:34 +02:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
|
|
|
|
2006-11-23 10:36:33 +01:00
|
|
|
git_config(git_log_config);
|
2008-02-18 08:26:03 +01:00
|
|
|
|
|
|
|
if (diff_use_color_default == -1)
|
|
|
|
diff_use_color_default = git_use_color_default;
|
|
|
|
|
2006-07-29 06:21:48 +02:00
|
|
|
init_revisions(&rev, prefix);
|
2006-04-21 19:27:34 +02:00
|
|
|
rev.always_show_header = 1;
|
2006-07-29 07:44:25 +02:00
|
|
|
cmd_log_init(argc, argv, prefix, &rev);
|
2006-06-25 14:39:35 +02:00
|
|
|
return cmd_log_walk(&rev);
|
2006-04-21 19:27:34 +02:00
|
|
|
}
|
2006-04-21 22:19:58 +02:00
|
|
|
|
2007-02-23 23:27:58 +01:00
|
|
|
/* format-patch */
|
|
|
|
#define FORMAT_PATCH_NAME_MAX 64
|
|
|
|
|
2006-05-05 01:16:40 +02:00
|
|
|
static int istitlechar(char c)
|
|
|
|
{
|
|
|
|
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
|
|
|
|
(c >= '0' && c <= '9') || c == '.' || c == '_';
|
|
|
|
}
|
|
|
|
|
2007-01-18 00:03:39 +01:00
|
|
|
static const char *fmt_patch_suffix = ".patch";
|
2007-11-04 04:38:24 +01:00
|
|
|
static int numbered = 0;
|
|
|
|
static int auto_number = 0;
|
2006-06-02 15:21:17 +02:00
|
|
|
|
2008-02-19 08:40:33 +01:00
|
|
|
static char **extra_hdr;
|
|
|
|
static int extra_hdr_nr;
|
|
|
|
static int extra_hdr_alloc;
|
|
|
|
|
|
|
|
static char **extra_to;
|
|
|
|
static int extra_to_nr;
|
|
|
|
static int extra_to_alloc;
|
|
|
|
|
|
|
|
static char **extra_cc;
|
|
|
|
static int extra_cc_nr;
|
|
|
|
static int extra_cc_alloc;
|
|
|
|
|
|
|
|
static void add_header(const char *value)
|
|
|
|
{
|
|
|
|
int len = strlen(value);
|
|
|
|
while (value[len - 1] == '\n')
|
|
|
|
len--;
|
|
|
|
if (!strncasecmp(value, "to: ", 4)) {
|
|
|
|
ALLOC_GROW(extra_to, extra_to_nr + 1, extra_to_alloc);
|
|
|
|
extra_to[extra_to_nr++] = xstrndup(value + 4, len - 4);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!strncasecmp(value, "cc: ", 4)) {
|
|
|
|
ALLOC_GROW(extra_cc, extra_cc_nr + 1, extra_cc_alloc);
|
|
|
|
extra_cc[extra_cc_nr++] = xstrndup(value + 4, len - 4);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ALLOC_GROW(extra_hdr, extra_hdr_nr + 1, extra_hdr_alloc);
|
|
|
|
extra_hdr[extra_hdr_nr++] = xstrndup(value, len);
|
|
|
|
}
|
|
|
|
|
2006-06-02 15:21:17 +02:00
|
|
|
static int git_format_config(const char *var, const char *value)
|
|
|
|
{
|
|
|
|
if (!strcmp(var, "format.headers")) {
|
2007-01-17 20:13:02 +01:00
|
|
|
if (!value)
|
|
|
|
die("format.headers without value");
|
2008-02-19 08:40:33 +01:00
|
|
|
add_header(value);
|
2006-06-02 15:21:17 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2007-01-17 20:12:03 +01:00
|
|
|
if (!strcmp(var, "format.suffix")) {
|
|
|
|
if (!value)
|
2008-02-11 22:09:16 +01:00
|
|
|
return config_error_nonbool(var);
|
2007-01-17 20:12:03 +01:00
|
|
|
fmt_patch_suffix = xstrdup(value);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-12-13 10:13:28 +01:00
|
|
|
if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff")) {
|
2006-07-09 08:28:21 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2007-11-04 04:38:24 +01:00
|
|
|
if (!strcmp(var, "format.numbered")) {
|
2008-02-11 22:09:16 +01:00
|
|
|
if (value && !strcasecmp(value, "auto")) {
|
2007-11-04 04:38:24 +01:00
|
|
|
auto_number = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
numbered = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-07-02 02:48:59 +02:00
|
|
|
|
2006-11-23 10:36:33 +01:00
|
|
|
return git_log_config(var, value);
|
2006-06-02 15:21:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-19 04:56:13 +01:00
|
|
|
static const char *get_oneline_for_filename(struct commit *commit,
|
|
|
|
int keep_subject)
|
|
|
|
{
|
|
|
|
static char filename[PATH_MAX];
|
|
|
|
char *sol;
|
|
|
|
int len = 0;
|
|
|
|
int suffix_len = strlen(fmt_patch_suffix) + 1;
|
|
|
|
|
|
|
|
sol = strstr(commit->buffer, "\n\n");
|
|
|
|
if (!sol)
|
|
|
|
filename[0] = '\0';
|
|
|
|
else {
|
|
|
|
int j, space = 0;
|
|
|
|
|
|
|
|
sol += 2;
|
|
|
|
/* strip [PATCH] or [PATCH blabla] */
|
|
|
|
if (!keep_subject && !prefixcmp(sol, "[PATCH")) {
|
|
|
|
char *eos = strchr(sol + 6, ']');
|
|
|
|
if (eos) {
|
|
|
|
while (isspace(*eos))
|
|
|
|
eos++;
|
|
|
|
sol = eos;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (j = 0;
|
|
|
|
j < FORMAT_PATCH_NAME_MAX - suffix_len - 5 &&
|
|
|
|
len < sizeof(filename) - suffix_len &&
|
|
|
|
sol[j] && sol[j] != '\n';
|
|
|
|
j++) {
|
|
|
|
if (istitlechar(sol[j])) {
|
|
|
|
if (space) {
|
|
|
|
filename[len++] = '-';
|
|
|
|
space = 0;
|
|
|
|
}
|
|
|
|
filename[len++] = sol[j];
|
|
|
|
if (sol[j] == '.')
|
|
|
|
while (sol[j + 1] == '.')
|
|
|
|
j++;
|
|
|
|
} else
|
|
|
|
space = 1;
|
|
|
|
}
|
|
|
|
while (filename[len - 1] == '.'
|
|
|
|
|| filename[len - 1] == '-')
|
|
|
|
len--;
|
|
|
|
filename[len] = '\0';
|
|
|
|
}
|
|
|
|
return filename;
|
|
|
|
}
|
|
|
|
|
2006-05-05 03:33:05 +02:00
|
|
|
static FILE *realstdout = NULL;
|
2006-06-06 17:46:23 +02:00
|
|
|
static const char *output_directory = NULL;
|
2006-05-05 03:33:05 +02:00
|
|
|
|
2008-02-19 04:56:13 +01:00
|
|
|
static int reopen_stdout(const char *oneline, int nr, int total)
|
2006-05-05 01:16:40 +02:00
|
|
|
{
|
2007-02-23 23:27:58 +01:00
|
|
|
char filename[PATH_MAX];
|
2006-05-05 03:33:32 +02:00
|
|
|
int len = 0;
|
2007-02-23 23:27:58 +01:00
|
|
|
int suffix_len = strlen(fmt_patch_suffix) + 1;
|
2006-05-05 01:16:40 +02:00
|
|
|
|
2006-05-05 03:33:32 +02:00
|
|
|
if (output_directory) {
|
2008-02-19 04:56:13 +01:00
|
|
|
len = snprintf(filename, sizeof(filename), "%s",
|
|
|
|
output_directory);
|
|
|
|
if (len >=
|
2007-02-23 23:27:58 +01:00
|
|
|
sizeof(filename) - FORMAT_PATCH_NAME_MAX - suffix_len)
|
|
|
|
return error("name of output directory is too long");
|
2006-05-05 03:33:32 +02:00
|
|
|
if (filename[len - 1] != '/')
|
|
|
|
filename[len++] = '/';
|
|
|
|
}
|
2006-05-05 01:16:40 +02:00
|
|
|
|
2008-02-19 04:56:13 +01:00
|
|
|
if (!oneline)
|
|
|
|
len += sprintf(filename + len, "%d", nr);
|
|
|
|
else {
|
|
|
|
len += sprintf(filename + len, "%04d-", nr);
|
|
|
|
len += snprintf(filename + len, sizeof(filename) - len - 1
|
|
|
|
- suffix_len, "%s", oneline);
|
2007-06-05 22:06:53 +02:00
|
|
|
strcpy(filename + len, fmt_patch_suffix);
|
2006-05-05 01:16:40 +02:00
|
|
|
}
|
2007-06-05 22:06:53 +02:00
|
|
|
|
2006-05-05 03:33:05 +02:00
|
|
|
fprintf(realstdout, "%s\n", filename);
|
2007-02-23 23:27:58 +01:00
|
|
|
if (freopen(filename, "w", stdout) == NULL)
|
|
|
|
return error("Cannot open patch file %s",filename);
|
|
|
|
|
2007-06-05 22:06:53 +02:00
|
|
|
return 0;
|
2006-05-05 01:16:40 +02:00
|
|
|
}
|
|
|
|
|
2007-04-10 02:01:27 +02:00
|
|
|
static void get_patch_ids(struct rev_info *rev, struct patch_ids *ids, const char *prefix)
|
2006-06-25 03:52:01 +02:00
|
|
|
{
|
|
|
|
struct rev_info check_rev;
|
|
|
|
struct commit *commit;
|
|
|
|
struct object *o1, *o2;
|
|
|
|
unsigned flags1, flags2;
|
|
|
|
|
|
|
|
if (rev->pending.nr != 2)
|
|
|
|
die("Need exactly one range.");
|
|
|
|
|
|
|
|
o1 = rev->pending.objects[0].item;
|
|
|
|
flags1 = o1->flags;
|
|
|
|
o2 = rev->pending.objects[1].item;
|
|
|
|
flags2 = o2->flags;
|
|
|
|
|
|
|
|
if ((flags1 & UNINTERESTING) == (flags2 & UNINTERESTING))
|
|
|
|
die("Not a range.");
|
|
|
|
|
2007-04-10 02:01:27 +02:00
|
|
|
init_patch_ids(ids);
|
2006-06-25 03:52:01 +02:00
|
|
|
|
|
|
|
/* given a range a..b get all patch ids for b..a */
|
2006-07-29 06:21:48 +02:00
|
|
|
init_revisions(&check_rev, prefix);
|
2006-06-25 03:52:01 +02:00
|
|
|
o1->flags ^= UNINTERESTING;
|
|
|
|
o2->flags ^= UNINTERESTING;
|
|
|
|
add_pending_object(&check_rev, o1, "o1");
|
|
|
|
add_pending_object(&check_rev, o2, "o2");
|
2008-02-18 08:31:56 +01:00
|
|
|
if (prepare_revision_walk(&check_rev))
|
|
|
|
die("revision walk setup failed");
|
2006-06-25 03:52:01 +02:00
|
|
|
|
|
|
|
while ((commit = get_revision(&check_rev)) != NULL) {
|
|
|
|
/* ignore merges */
|
|
|
|
if (commit->parents && commit->parents->next)
|
|
|
|
continue;
|
|
|
|
|
2007-04-10 02:01:27 +02:00
|
|
|
add_commit_patch_id(commit, ids);
|
2006-06-25 03:52:01 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* reset for next revision walk */
|
2006-06-27 22:38:04 +02:00
|
|
|
clear_commit_marks((struct commit *)o1,
|
|
|
|
SEEN | UNINTERESTING | SHOWN | ADDED);
|
|
|
|
clear_commit_marks((struct commit *)o2,
|
|
|
|
SEEN | UNINTERESTING | SHOWN | ADDED);
|
2006-06-25 03:52:01 +02:00
|
|
|
o1->flags = flags1;
|
|
|
|
o2->flags = flags2;
|
|
|
|
}
|
|
|
|
|
2008-02-19 04:56:06 +01:00
|
|
|
static void gen_message_id(struct rev_info *info, char *base)
|
2006-07-15 02:48:51 +02:00
|
|
|
{
|
2007-12-09 02:32:08 +01:00
|
|
|
const char *committer = git_committer_info(IDENT_WARN_ON_NO_NAME);
|
2006-07-15 02:48:51 +02:00
|
|
|
const char *email_start = strrchr(committer, '<');
|
|
|
|
const char *email_end = strrchr(committer, '>');
|
2008-02-19 04:56:06 +01:00
|
|
|
struct strbuf buf;
|
|
|
|
if (!email_start || !email_end || email_start > email_end - 1)
|
2006-07-15 02:48:51 +02:00
|
|
|
die("Could not extract email from committer identity.");
|
2008-02-19 04:56:06 +01:00
|
|
|
strbuf_init(&buf, 0);
|
|
|
|
strbuf_addf(&buf, "%s.%lu.git.%.*s", base,
|
|
|
|
(unsigned long) time(NULL),
|
|
|
|
(int)(email_end - email_start - 1), email_start + 1);
|
|
|
|
info->message_id = strbuf_detach(&buf, NULL);
|
2006-07-15 02:48:51 +02:00
|
|
|
}
|
|
|
|
|
2008-02-26 00:24:17 +01:00
|
|
|
static void make_cover_letter(struct rev_info *rev, int use_stdout,
|
|
|
|
int numbered, int numbered_files,
|
|
|
|
struct commit *origin,
|
|
|
|
int nr, struct commit **list, struct commit *head)
|
2008-02-19 04:56:13 +01:00
|
|
|
{
|
|
|
|
const char *committer;
|
2008-02-28 18:14:13 +01:00
|
|
|
char *head_sha1;
|
2008-02-19 04:56:13 +01:00
|
|
|
const char *subject_start = NULL;
|
|
|
|
const char *body = "*** SUBJECT HERE ***\n\n*** BLURB HERE ***\n";
|
|
|
|
const char *msg;
|
|
|
|
const char *extra_headers = rev->extra_headers;
|
2008-02-26 00:24:17 +01:00
|
|
|
struct shortlog log;
|
2008-02-19 04:56:13 +01:00
|
|
|
struct strbuf sb;
|
2008-02-26 00:24:17 +01:00
|
|
|
int i;
|
2008-02-19 04:56:13 +01:00
|
|
|
const char *encoding = "utf-8";
|
2008-02-28 18:14:13 +01:00
|
|
|
struct diff_options opts;
|
2008-03-15 08:09:20 +01:00
|
|
|
int need_8bit_cte = 0;
|
2008-02-19 04:56:13 +01:00
|
|
|
|
|
|
|
if (rev->commit_format != CMIT_FMT_EMAIL)
|
|
|
|
die("Cover letter needs email format");
|
|
|
|
|
|
|
|
if (!use_stdout && reopen_stdout(numbered_files ?
|
|
|
|
NULL : "cover-letter", 0, rev->total))
|
|
|
|
return;
|
|
|
|
|
|
|
|
head_sha1 = sha1_to_hex(head->object.sha1);
|
|
|
|
|
2008-03-15 08:09:20 +01:00
|
|
|
log_write_email_headers(rev, head_sha1, &subject_start, &extra_headers,
|
|
|
|
&need_8bit_cte);
|
2008-02-19 04:56:13 +01:00
|
|
|
|
|
|
|
committer = git_committer_info(0);
|
|
|
|
|
|
|
|
msg = body;
|
|
|
|
strbuf_init(&sb, 0);
|
|
|
|
pp_user_info(NULL, CMIT_FMT_EMAIL, &sb, committer, DATE_RFC2822,
|
|
|
|
encoding);
|
|
|
|
pp_title_line(CMIT_FMT_EMAIL, &msg, &sb, subject_start, extra_headers,
|
2008-03-15 08:09:20 +01:00
|
|
|
encoding, need_8bit_cte);
|
2008-02-19 04:56:13 +01:00
|
|
|
pp_remainder(CMIT_FMT_EMAIL, &msg, &sb, 0);
|
|
|
|
printf("%s\n", sb.buf);
|
|
|
|
|
|
|
|
strbuf_release(&sb);
|
|
|
|
|
2008-02-26 00:24:17 +01:00
|
|
|
shortlog_init(&log);
|
2008-03-02 16:53:39 +01:00
|
|
|
log.wrap_lines = 1;
|
|
|
|
log.wrap = 72;
|
|
|
|
log.in1 = 2;
|
|
|
|
log.in2 = 4;
|
2008-02-26 00:24:17 +01:00
|
|
|
for (i = 0; i < nr; i++)
|
|
|
|
shortlog_add_commit(&log, list[i]);
|
|
|
|
|
|
|
|
shortlog_output(&log);
|
|
|
|
|
2008-02-19 04:56:13 +01:00
|
|
|
/*
|
2008-02-26 00:24:17 +01:00
|
|
|
* We can only do diffstat with a unique reference point
|
2008-02-19 04:56:13 +01:00
|
|
|
*/
|
|
|
|
if (!origin)
|
|
|
|
return;
|
|
|
|
|
2008-03-02 16:53:04 +01:00
|
|
|
memcpy(&opts, &rev->diffopt, sizeof(opts));
|
|
|
|
opts.output_format = DIFF_FORMAT_SUMMARY | DIFF_FORMAT_DIFFSTAT;
|
2008-02-19 04:56:13 +01:00
|
|
|
|
2008-02-28 18:14:13 +01:00
|
|
|
diff_setup_done(&opts);
|
|
|
|
|
|
|
|
diff_tree_sha1(origin->tree->object.sha1,
|
|
|
|
head->tree->object.sha1,
|
|
|
|
"", &opts);
|
|
|
|
diffcore_std(&opts);
|
|
|
|
diff_flush(&opts);
|
2008-02-19 04:56:13 +01:00
|
|
|
|
|
|
|
printf("\n");
|
2006-07-15 02:48:51 +02:00
|
|
|
}
|
|
|
|
|
2007-09-14 07:30:45 +02:00
|
|
|
static const char *clean_message_id(const char *msg_id)
|
|
|
|
{
|
|
|
|
char ch;
|
|
|
|
const char *a, *z, *m;
|
|
|
|
|
|
|
|
m = msg_id;
|
|
|
|
while ((ch = *m) && (isspace(ch) || (ch == '<')))
|
|
|
|
m++;
|
|
|
|
a = m;
|
|
|
|
z = NULL;
|
|
|
|
while ((ch = *m)) {
|
|
|
|
if (!isspace(ch) && (ch != '>'))
|
|
|
|
z = m;
|
|
|
|
m++;
|
|
|
|
}
|
|
|
|
if (!z)
|
|
|
|
die("insane in-reply-to: %s", msg_id);
|
|
|
|
if (++z == m)
|
|
|
|
return a;
|
2007-09-16 00:32:36 +02:00
|
|
|
return xmemdupz(a, z - a);
|
2007-09-14 07:30:45 +02:00
|
|
|
}
|
|
|
|
|
2006-07-29 07:44:25 +02:00
|
|
|
int cmd_format_patch(int argc, const char **argv, const char *prefix)
|
2006-04-21 22:19:58 +02:00
|
|
|
{
|
|
|
|
struct commit *commit;
|
|
|
|
struct commit **list = NULL;
|
|
|
|
struct rev_info rev;
|
2006-05-05 03:33:32 +02:00
|
|
|
int nr = 0, total, i, j;
|
2006-05-05 01:16:40 +02:00
|
|
|
int use_stdout = 0;
|
2006-05-25 23:55:11 +02:00
|
|
|
int start_number = -1;
|
2006-05-05 04:31:29 +02:00
|
|
|
int keep_subject = 0;
|
2007-06-05 22:06:53 +02:00
|
|
|
int numbered_files = 0; /* _just_ numbers */
|
2007-04-12 01:58:07 +02:00
|
|
|
int subject_prefix = 0;
|
2006-06-25 03:52:01 +02:00
|
|
|
int ignore_if_in_upstream = 0;
|
2006-07-15 02:49:04 +02:00
|
|
|
int thread = 0;
|
2008-02-19 04:56:13 +01:00
|
|
|
int cover_letter = 0;
|
2008-02-26 00:24:17 +01:00
|
|
|
int boundary_count = 0;
|
2008-02-19 04:56:13 +01:00
|
|
|
struct commit *origin = NULL, *head = NULL;
|
2006-07-15 07:47:53 +02:00
|
|
|
const char *in_reply_to = NULL;
|
2007-04-10 02:01:27 +02:00
|
|
|
struct patch_ids ids;
|
2006-06-01 00:11:49 +02:00
|
|
|
char *add_signoff = NULL;
|
2008-02-19 08:40:33 +01:00
|
|
|
struct strbuf buf;
|
2006-04-21 22:19:58 +02:00
|
|
|
|
2006-07-07 12:10:45 +02:00
|
|
|
git_config(git_format_config);
|
2006-07-29 06:21:48 +02:00
|
|
|
init_revisions(&rev, prefix);
|
2006-04-21 22:19:58 +02:00
|
|
|
rev.commit_format = CMIT_FMT_EMAIL;
|
|
|
|
rev.verbose_header = 1;
|
|
|
|
rev.diff = 1;
|
|
|
|
rev.combine_merges = 0;
|
|
|
|
rev.ignore_merges = 1;
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(&rev.diffopt, RECURSIVE);
|
2006-04-21 22:19:58 +02:00
|
|
|
|
2007-07-02 02:48:59 +02:00
|
|
|
rev.subject_prefix = fmt_patch_subject_prefix;
|
2006-06-02 15:21:17 +02:00
|
|
|
|
2006-05-05 03:33:32 +02:00
|
|
|
/*
|
|
|
|
* Parse the arguments before setup_revisions(), or something
|
2007-05-14 16:44:51 +02:00
|
|
|
* like "git format-patch -o a123 HEAD^.." may fail; a123 is
|
2006-05-05 03:33:32 +02:00
|
|
|
* possibly a valid SHA1.
|
|
|
|
*/
|
|
|
|
for (i = 1, j = 1; i < argc; i++) {
|
|
|
|
if (!strcmp(argv[i], "--stdout"))
|
2006-05-05 01:16:40 +02:00
|
|
|
use_stdout = 1;
|
2006-05-05 04:30:52 +02:00
|
|
|
else if (!strcmp(argv[i], "-n") ||
|
|
|
|
!strcmp(argv[i], "--numbered"))
|
|
|
|
numbered = 1;
|
2007-11-04 04:38:24 +01:00
|
|
|
else if (!strcmp(argv[i], "-N") ||
|
|
|
|
!strcmp(argv[i], "--no-numbered")) {
|
|
|
|
numbered = 0;
|
|
|
|
auto_number = 0;
|
|
|
|
}
|
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 10:53:29 +01:00
|
|
|
else if (!prefixcmp(argv[i], "--start-number="))
|
2006-05-25 23:55:11 +02:00
|
|
|
start_number = strtol(argv[i] + 15, NULL, 10);
|
2007-06-05 22:06:53 +02:00
|
|
|
else if (!strcmp(argv[i], "--numbered-files"))
|
|
|
|
numbered_files = 1;
|
2006-05-25 23:55:11 +02:00
|
|
|
else if (!strcmp(argv[i], "--start-number")) {
|
|
|
|
i++;
|
|
|
|
if (i == argc)
|
|
|
|
die("Need a number for --start-number");
|
|
|
|
start_number = strtol(argv[i], NULL, 10);
|
2006-06-01 00:11:49 +02:00
|
|
|
}
|
2008-02-19 08:40:35 +01:00
|
|
|
else if (!prefixcmp(argv[i], "--cc=")) {
|
|
|
|
ALLOC_GROW(extra_cc, extra_cc_nr + 1, extra_cc_alloc);
|
|
|
|
extra_cc[extra_cc_nr++] = xstrdup(argv[i] + 5);
|
|
|
|
}
|
2006-06-01 00:11:49 +02:00
|
|
|
else if (!strcmp(argv[i], "-k") ||
|
2006-05-05 04:31:29 +02:00
|
|
|
!strcmp(argv[i], "--keep-subject")) {
|
|
|
|
keep_subject = 1;
|
|
|
|
rev.total = -1;
|
2006-06-01 00:11:49 +02:00
|
|
|
}
|
2006-06-06 17:46:23 +02:00
|
|
|
else if (!strcmp(argv[i], "--output-directory") ||
|
|
|
|
!strcmp(argv[i], "-o")) {
|
2006-05-05 03:33:32 +02:00
|
|
|
i++;
|
2006-06-06 17:46:23 +02:00
|
|
|
if (argc <= i)
|
|
|
|
die("Which directory?");
|
|
|
|
if (output_directory)
|
|
|
|
die("Two output directories?");
|
|
|
|
output_directory = argv[i];
|
2006-05-20 15:40:29 +02:00
|
|
|
}
|
2006-06-01 00:11:49 +02:00
|
|
|
else if (!strcmp(argv[i], "--signoff") ||
|
|
|
|
!strcmp(argv[i], "-s")) {
|
2006-06-12 21:31:38 +02:00
|
|
|
const char *committer;
|
|
|
|
const char *endpos;
|
2007-12-09 02:32:08 +01:00
|
|
|
committer = git_committer_info(IDENT_ERROR_ON_NO_NAME);
|
2006-06-12 21:31:38 +02:00
|
|
|
endpos = strchr(committer, '>');
|
2006-06-01 00:11:49 +02:00
|
|
|
if (!endpos)
|
|
|
|
die("bogos committer info %s\n", committer);
|
2007-09-16 00:32:36 +02:00
|
|
|
add_signoff = xmemdupz(committer, endpos - committer + 1);
|
2006-06-01 00:11:49 +02:00
|
|
|
}
|
2007-03-04 00:12:06 +01:00
|
|
|
else if (!strcmp(argv[i], "--attach")) {
|
2006-05-20 15:40:29 +02:00
|
|
|
rev.mime_boundary = git_version_string;
|
2007-03-04 00:12:06 +01:00
|
|
|
rev.no_inline = 1;
|
|
|
|
}
|
|
|
|
else if (!prefixcmp(argv[i], "--attach=")) {
|
|
|
|
rev.mime_boundary = argv[i] + 9;
|
|
|
|
rev.no_inline = 1;
|
|
|
|
}
|
|
|
|
else if (!strcmp(argv[i], "--inline")) {
|
|
|
|
rev.mime_boundary = git_version_string;
|
|
|
|
rev.no_inline = 0;
|
|
|
|
}
|
|
|
|
else if (!prefixcmp(argv[i], "--inline=")) {
|
2006-05-20 15:40:29 +02:00
|
|
|
rev.mime_boundary = argv[i] + 9;
|
2007-03-04 00:12:06 +01:00
|
|
|
rev.no_inline = 0;
|
|
|
|
}
|
2006-06-25 03:52:01 +02:00
|
|
|
else if (!strcmp(argv[i], "--ignore-if-in-upstream"))
|
|
|
|
ignore_if_in_upstream = 1;
|
2006-07-15 02:49:04 +02:00
|
|
|
else if (!strcmp(argv[i], "--thread"))
|
|
|
|
thread = 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 10:53:29 +01:00
|
|
|
else if (!prefixcmp(argv[i], "--in-reply-to="))
|
2006-07-15 02:49:08 +02:00
|
|
|
in_reply_to = argv[i] + 14;
|
|
|
|
else if (!strcmp(argv[i], "--in-reply-to")) {
|
|
|
|
i++;
|
|
|
|
if (i == argc)
|
|
|
|
die("Need a Message-Id for --in-reply-to");
|
|
|
|
in_reply_to = argv[i];
|
2007-04-12 01:58:07 +02:00
|
|
|
} else if (!prefixcmp(argv[i], "--subject-prefix=")) {
|
|
|
|
subject_prefix = 1;
|
|
|
|
rev.subject_prefix = argv[i] + 17;
|
|
|
|
} else if (!prefixcmp(argv[i], "--suffix="))
|
2007-01-17 20:12:03 +01:00
|
|
|
fmt_patch_suffix = argv[i] + 9;
|
2008-02-19 04:56:13 +01:00
|
|
|
else if (!strcmp(argv[i], "--cover-letter"))
|
|
|
|
cover_letter = 1;
|
2006-05-20 15:40:29 +02:00
|
|
|
else
|
2006-05-05 03:33:32 +02:00
|
|
|
argv[j++] = argv[i];
|
2006-05-05 01:16:40 +02:00
|
|
|
}
|
2006-05-05 03:33:32 +02:00
|
|
|
argc = j;
|
|
|
|
|
2008-02-19 08:40:33 +01:00
|
|
|
strbuf_init(&buf, 0);
|
|
|
|
|
|
|
|
for (i = 0; i < extra_hdr_nr; i++) {
|
|
|
|
strbuf_addstr(&buf, extra_hdr[i]);
|
|
|
|
strbuf_addch(&buf, '\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
if (extra_to_nr)
|
|
|
|
strbuf_addstr(&buf, "To: ");
|
|
|
|
for (i = 0; i < extra_to_nr; i++) {
|
|
|
|
if (i)
|
|
|
|
strbuf_addstr(&buf, " ");
|
|
|
|
strbuf_addstr(&buf, extra_to[i]);
|
|
|
|
if (i + 1 < extra_to_nr)
|
|
|
|
strbuf_addch(&buf, ',');
|
|
|
|
strbuf_addch(&buf, '\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
if (extra_cc_nr)
|
|
|
|
strbuf_addstr(&buf, "Cc: ");
|
|
|
|
for (i = 0; i < extra_cc_nr; i++) {
|
|
|
|
if (i)
|
|
|
|
strbuf_addstr(&buf, " ");
|
|
|
|
strbuf_addstr(&buf, extra_cc[i]);
|
|
|
|
if (i + 1 < extra_cc_nr)
|
|
|
|
strbuf_addch(&buf, ',');
|
|
|
|
strbuf_addch(&buf, '\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
rev.extra_headers = strbuf_detach(&buf, 0);
|
|
|
|
|
2006-05-26 20:30:49 +02:00
|
|
|
if (start_number < 0)
|
2006-05-25 23:55:11 +02:00
|
|
|
start_number = 1;
|
2006-05-28 18:23:29 +02:00
|
|
|
if (numbered && keep_subject)
|
2006-05-05 04:31:29 +02:00
|
|
|
die ("-n and -k are mutually exclusive.");
|
2007-04-12 01:58:07 +02:00
|
|
|
if (keep_subject && subject_prefix)
|
|
|
|
die ("--subject-prefix and -k are mutually exclusive.");
|
2007-06-05 22:06:53 +02:00
|
|
|
if (numbered_files && use_stdout)
|
|
|
|
die ("--numbered-files and --stdout are mutually exclusive.");
|
2006-05-05 04:31:29 +02:00
|
|
|
|
2006-05-05 03:33:32 +02:00
|
|
|
argc = setup_revisions(argc, argv, &rev, "HEAD");
|
|
|
|
if (argc > 1)
|
|
|
|
die ("unrecognized argument: %s", argv[1]);
|
2006-05-05 01:16:40 +02:00
|
|
|
|
2006-06-24 19:24:14 +02:00
|
|
|
if (!rev.diffopt.output_format)
|
2007-01-17 22:51:44 +01:00
|
|
|
rev.diffopt.output_format = DIFF_FORMAT_DIFFSTAT | DIFF_FORMAT_SUMMARY | DIFF_FORMAT_PATCH;
|
2006-06-24 19:24:14 +02:00
|
|
|
|
2007-11-10 20:05:14 +01:00
|
|
|
if (!DIFF_OPT_TST(&rev.diffopt, TEXT))
|
|
|
|
DIFF_OPT_SET(&rev.diffopt, BINARY);
|
2007-01-17 23:32:52 +01:00
|
|
|
|
2007-01-23 04:38:28 +01:00
|
|
|
if (!output_directory && !use_stdout)
|
2006-09-28 21:55:35 +02:00
|
|
|
output_directory = prefix;
|
|
|
|
|
2006-06-06 17:46:23 +02:00
|
|
|
if (output_directory) {
|
|
|
|
if (use_stdout)
|
|
|
|
die("standard output, or directory, which one?");
|
|
|
|
if (mkdir(output_directory, 0777) < 0 && errno != EEXIST)
|
|
|
|
die("Could not create directory %s",
|
|
|
|
output_directory);
|
|
|
|
}
|
|
|
|
|
Add "named object array" concept
We've had this notion of a "object_list" for a long time, which eventually
grew a "name" member because some users (notably git-rev-list) wanted to
name each object as it is generated.
That object_list is great for some things, but it isn't all that wonderful
for others, and the "name" member is generally not used by everybody.
This patch splits the users of the object_list array up into two: the
traditional list users, who want the list-like format, and who don't
actually use or want the name. And another class of users that really used
the list as an extensible array, and generally wanted to name the objects.
The patch is fairly straightforward, but it's also biggish. Most of it
really just cleans things up: switching the revision parsing and listing
over to the array makes things like the builtin-diff usage much simpler
(we now see exactly how many members the array has, and we don't get the
objects reversed from the order they were on the command line).
One of the main reasons for doing this at all is that the malloc overhead
of the simple object list was actually pretty high, and the array is just
a lot denser. So this patch brings down memory usage by git-rev-list by
just under 3% (on top of all the other memory use optimizations) on the
mozilla archive.
It does add more lines than it removes, and more importantly, it adds a
whole new infrastructure for maintaining lists of objects, but on the
other hand, the new dynamic array code is pretty obvious. The change to
builtin-diff-tree.c shows a fairly good example of why an array interface
is sometimes more natural, and just much simpler for everybody.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 02:42:35 +02:00
|
|
|
if (rev.pending.nr == 1) {
|
2007-08-28 09:38:48 +02:00
|
|
|
if (rev.max_count < 0 && !rev.show_root_diff) {
|
|
|
|
/*
|
|
|
|
* This is traditional behaviour of "git format-patch
|
|
|
|
* origin" that prepares what the origin side still
|
|
|
|
* does not have.
|
|
|
|
*/
|
2007-01-17 22:35:13 +01:00
|
|
|
rev.pending.objects[0].item->flags |= UNINTERESTING;
|
2007-12-11 19:09:04 +01:00
|
|
|
add_head_to_pending(&rev);
|
2007-01-17 22:35:13 +01:00
|
|
|
}
|
2007-08-28 09:38:48 +02:00
|
|
|
/*
|
|
|
|
* Otherwise, it is "format-patch -22 HEAD", and/or
|
|
|
|
* "format-patch --root HEAD". The user wants
|
|
|
|
* get_revision() to do the usual traversal.
|
2007-01-17 22:35:13 +01:00
|
|
|
*/
|
2006-05-06 22:56:38 +02:00
|
|
|
}
|
2008-02-19 04:56:13 +01:00
|
|
|
if (cover_letter) {
|
|
|
|
/* remember the range */
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < rev.pending.nr; i++) {
|
|
|
|
struct object *o = rev.pending.objects[i].item;
|
2008-02-26 00:24:17 +01:00
|
|
|
if (!(o->flags & UNINTERESTING))
|
2008-02-19 04:56:13 +01:00
|
|
|
head = (struct commit *)o;
|
|
|
|
}
|
|
|
|
/* We can't generate a cover letter without any patches */
|
|
|
|
if (!head)
|
|
|
|
return 0;
|
|
|
|
}
|
2006-05-06 22:56:38 +02:00
|
|
|
|
2006-06-25 03:52:01 +02:00
|
|
|
if (ignore_if_in_upstream)
|
2007-04-10 02:01:27 +02:00
|
|
|
get_patch_ids(&rev, &ids, prefix);
|
2006-06-25 03:52:01 +02:00
|
|
|
|
2006-05-05 03:33:05 +02:00
|
|
|
if (!use_stdout)
|
2007-06-27 16:28:53 +02:00
|
|
|
realstdout = xfdopen(xdup(1), "w");
|
2006-05-05 03:33:05 +02:00
|
|
|
|
2008-02-18 08:31:56 +01:00
|
|
|
if (prepare_revision_walk(&rev))
|
|
|
|
die("revision walk setup failed");
|
2008-02-26 00:24:17 +01:00
|
|
|
rev.boundary = 1;
|
2006-04-21 22:19:58 +02:00
|
|
|
while ((commit = get_revision(&rev)) != NULL) {
|
2008-02-26 00:24:17 +01:00
|
|
|
if (commit->object.flags & BOUNDARY) {
|
|
|
|
boundary_count++;
|
|
|
|
origin = (boundary_count == 1) ? commit : NULL;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2006-05-05 01:16:40 +02:00
|
|
|
/* ignore merges */
|
|
|
|
if (commit->parents && commit->parents->next)
|
|
|
|
continue;
|
2006-06-25 03:52:01 +02:00
|
|
|
|
|
|
|
if (ignore_if_in_upstream &&
|
2007-04-10 02:01:27 +02:00
|
|
|
has_commit_patch_id(commit, &ids))
|
2006-06-25 03:52:01 +02:00
|
|
|
continue;
|
|
|
|
|
2006-04-21 22:19:58 +02:00
|
|
|
nr++;
|
2006-08-26 16:16:18 +02:00
|
|
|
list = xrealloc(list, nr * sizeof(list[0]));
|
2006-04-21 22:19:58 +02:00
|
|
|
list[nr - 1] = commit;
|
|
|
|
}
|
2006-05-05 01:16:40 +02:00
|
|
|
total = nr;
|
2007-11-04 04:38:24 +01:00
|
|
|
if (!keep_subject && auto_number && total > 1)
|
|
|
|
numbered = 1;
|
2006-05-05 04:30:52 +02:00
|
|
|
if (numbered)
|
2006-05-25 23:55:11 +02:00
|
|
|
rev.total = total + start_number - 1;
|
2007-09-14 07:30:45 +02:00
|
|
|
if (in_reply_to)
|
|
|
|
rev.ref_message_id = clean_message_id(in_reply_to);
|
2008-02-19 04:56:13 +01:00
|
|
|
if (cover_letter) {
|
|
|
|
if (thread)
|
|
|
|
gen_message_id(&rev, "cover");
|
|
|
|
make_cover_letter(&rev, use_stdout, numbered, numbered_files,
|
2008-02-26 00:24:17 +01:00
|
|
|
origin, nr, list, head);
|
2008-02-19 04:56:13 +01:00
|
|
|
total++;
|
|
|
|
start_number--;
|
|
|
|
}
|
|
|
|
rev.add_signoff = add_signoff;
|
2006-04-21 22:19:58 +02:00
|
|
|
while (0 <= --nr) {
|
|
|
|
int shown;
|
|
|
|
commit = list[nr];
|
2006-05-26 20:30:49 +02:00
|
|
|
rev.nr = total - nr + (start_number - 1);
|
2006-07-15 02:48:51 +02:00
|
|
|
/* Make the second and subsequent mails replies to the first */
|
2006-07-15 02:49:04 +02:00
|
|
|
if (thread) {
|
2008-02-19 04:56:13 +01:00
|
|
|
/* Have we already had a message ID? */
|
2008-02-19 04:56:06 +01:00
|
|
|
if (rev.message_id) {
|
2008-02-19 04:56:13 +01:00
|
|
|
/*
|
|
|
|
* If we've got the ID to be a reply
|
|
|
|
* to, discard the current ID;
|
|
|
|
* otherwise, make everything a reply
|
|
|
|
* to that.
|
|
|
|
*/
|
2008-02-19 04:56:06 +01:00
|
|
|
if (rev.ref_message_id)
|
|
|
|
free(rev.message_id);
|
|
|
|
else
|
|
|
|
rev.ref_message_id = rev.message_id;
|
2006-07-15 02:49:04 +02:00
|
|
|
}
|
2008-02-19 04:56:06 +01:00
|
|
|
gen_message_id(&rev, sha1_to_hex(commit->object.sha1));
|
2006-07-15 02:48:51 +02:00
|
|
|
}
|
2008-02-19 04:56:13 +01:00
|
|
|
if (!use_stdout && reopen_stdout(numbered_files ? NULL :
|
|
|
|
get_oneline_for_filename(commit, keep_subject),
|
|
|
|
rev.nr, rev.total))
|
|
|
|
die("Failed to create output files");
|
2006-04-21 22:19:58 +02:00
|
|
|
shown = log_tree_commit(&rev, commit);
|
|
|
|
free(commit->buffer);
|
|
|
|
commit->buffer = NULL;
|
2006-05-26 20:30:49 +02:00
|
|
|
|
|
|
|
/* We put one extra blank line between formatted
|
|
|
|
* patches and this flag is used by log-tree code
|
|
|
|
* to see if it needs to emit a LF before showing
|
|
|
|
* the log; when using one file per patch, we do
|
|
|
|
* not want the extra blank line.
|
|
|
|
*/
|
|
|
|
if (!use_stdout)
|
|
|
|
rev.shown_one = 0;
|
2006-05-20 15:40:29 +02:00
|
|
|
if (shown) {
|
|
|
|
if (rev.mime_boundary)
|
|
|
|
printf("\n--%s%s--\n\n\n",
|
|
|
|
mime_boundary_leader,
|
|
|
|
rev.mime_boundary);
|
|
|
|
else
|
|
|
|
printf("-- \n%s\n\n", git_version_string);
|
|
|
|
}
|
2006-05-05 01:16:40 +02:00
|
|
|
if (!use_stdout)
|
|
|
|
fclose(stdout);
|
2006-04-21 22:19:58 +02:00
|
|
|
}
|
|
|
|
free(list);
|
2007-04-10 02:01:27 +02:00
|
|
|
if (ignore_if_in_upstream)
|
|
|
|
free_patch_ids(&ids);
|
2006-04-21 22:19:58 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-24 01:01:57 +02:00
|
|
|
static int add_pending_commit(const char *arg, struct rev_info *revs, int flags)
|
|
|
|
{
|
|
|
|
unsigned char sha1[20];
|
|
|
|
if (get_sha1(arg, sha1) == 0) {
|
|
|
|
struct commit *commit = lookup_commit_reference(sha1);
|
|
|
|
if (commit) {
|
|
|
|
commit->object.flags |= flags;
|
|
|
|
add_pending_object(revs, &commit->object, arg);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char cherry_usage[] =
|
|
|
|
"git-cherry [-v] <upstream> [<head>] [<limit>]";
|
|
|
|
int cmd_cherry(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
struct rev_info revs;
|
2007-04-10 02:01:27 +02:00
|
|
|
struct patch_ids ids;
|
2006-10-24 01:01:57 +02:00
|
|
|
struct commit *commit;
|
|
|
|
struct commit_list *list = NULL;
|
|
|
|
const char *upstream;
|
|
|
|
const char *head = "HEAD";
|
|
|
|
const char *limit = NULL;
|
|
|
|
int verbose = 0;
|
|
|
|
|
|
|
|
if (argc > 1 && !strcmp(argv[1], "-v")) {
|
|
|
|
verbose = 1;
|
|
|
|
argc--;
|
|
|
|
argv++;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (argc) {
|
|
|
|
case 4:
|
|
|
|
limit = argv[3];
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
case 3:
|
|
|
|
head = argv[2];
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
case 2:
|
|
|
|
upstream = argv[1];
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
usage(cherry_usage);
|
|
|
|
}
|
|
|
|
|
|
|
|
init_revisions(&revs, prefix);
|
|
|
|
revs.diff = 1;
|
|
|
|
revs.combine_merges = 0;
|
|
|
|
revs.ignore_merges = 1;
|
2007-11-10 20:05:14 +01:00
|
|
|
DIFF_OPT_SET(&revs.diffopt, RECURSIVE);
|
2006-10-24 01:01:57 +02:00
|
|
|
|
|
|
|
if (add_pending_commit(head, &revs, 0))
|
|
|
|
die("Unknown commit %s", head);
|
|
|
|
if (add_pending_commit(upstream, &revs, UNINTERESTING))
|
|
|
|
die("Unknown commit %s", upstream);
|
|
|
|
|
|
|
|
/* Don't say anything if head and upstream are the same. */
|
|
|
|
if (revs.pending.nr == 2) {
|
|
|
|
struct object_array_entry *o = revs.pending.objects;
|
|
|
|
if (hashcmp(o[0].item->sha1, o[1].item->sha1) == 0)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-10 02:01:27 +02:00
|
|
|
get_patch_ids(&revs, &ids, prefix);
|
2006-10-24 01:01:57 +02:00
|
|
|
|
|
|
|
if (limit && add_pending_commit(limit, &revs, UNINTERESTING))
|
|
|
|
die("Unknown commit %s", limit);
|
|
|
|
|
|
|
|
/* reverse the list of commits */
|
2008-02-18 08:31:56 +01:00
|
|
|
if (prepare_revision_walk(&revs))
|
|
|
|
die("revision walk setup failed");
|
2006-10-24 01:01:57 +02:00
|
|
|
while ((commit = get_revision(&revs)) != NULL) {
|
|
|
|
/* ignore merges */
|
|
|
|
if (commit->parents && commit->parents->next)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
commit_list_insert(commit, &list);
|
|
|
|
}
|
|
|
|
|
|
|
|
while (list) {
|
|
|
|
char sign = '+';
|
|
|
|
|
|
|
|
commit = list->item;
|
2007-04-10 02:01:27 +02:00
|
|
|
if (has_commit_patch_id(commit, &ids))
|
2006-10-24 01:01:57 +02:00
|
|
|
sign = '-';
|
|
|
|
|
|
|
|
if (verbose) {
|
2007-09-10 12:35:06 +02:00
|
|
|
struct strbuf buf;
|
|
|
|
strbuf_init(&buf, 0);
|
|
|
|
pretty_print_commit(CMIT_FMT_ONELINE, commit,
|
2007-10-31 22:55:17 +01:00
|
|
|
&buf, 0, NULL, NULL, 0, 0);
|
2006-10-24 01:01:57 +02:00
|
|
|
printf("%c %s %s\n", sign,
|
2007-09-10 12:35:06 +02:00
|
|
|
sha1_to_hex(commit->object.sha1), buf.buf);
|
|
|
|
strbuf_release(&buf);
|
2006-10-24 01:01:57 +02:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
printf("%c %s\n", sign,
|
|
|
|
sha1_to_hex(commit->object.sha1));
|
|
|
|
}
|
|
|
|
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
|
2007-04-10 02:01:27 +02:00
|
|
|
free_patch_ids(&ids);
|
2006-10-24 01:01:57 +02:00
|
|
|
return 0;
|
|
|
|
}
|