2006-04-21 17:27:34 +00:00
|
|
|
/*
|
|
|
|
* Builtin "git log" and related commands (show, whatchanged)
|
|
|
|
*
|
|
|
|
* (C) Copyright 2006 Linus Torvalds
|
|
|
|
* 2006 Junio Hamano
|
|
|
|
*/
|
|
|
|
#include "cache.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "revision.h"
|
|
|
|
#include "log-tree.h"
|
2006-04-21 20:19:58 +00:00
|
|
|
#include "builtin.h"
|
2006-12-14 10:31:05 +00:00
|
|
|
#include "tag.h"
|
2007-02-08 17:51:56 +00:00
|
|
|
#include "reflog-walk.h"
|
2007-04-10 00:01:27 +00:00
|
|
|
#include "patch-ids.h"
|
2007-04-16 23:05:10 +00:00
|
|
|
#include "refs.h"
|
2006-04-21 17:27:34 +00:00
|
|
|
|
2006-11-23 09:36:33 +00:00
|
|
|
static int default_show_root = 1;
|
|
|
|
|
2006-05-06 20:56:38 +00:00
|
|
|
/* this is in builtin-diff.c */
|
|
|
|
void add_head(struct rev_info *revs);
|
|
|
|
|
2007-04-16 23:05:10 +00: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 05:44:25 +00:00
|
|
|
static void cmd_log_init(int argc, const char **argv, const char *prefix,
|
2006-04-21 17:27:34 +00:00
|
|
|
struct rev_info *rev)
|
|
|
|
{
|
2006-12-25 19:48:35 +00:00
|
|
|
int i;
|
2007-04-16 23:05:10 +00:00
|
|
|
int decorate = 0;
|
2006-12-25 19:48:35 +00:00
|
|
|
|
2006-04-21 17:27:34 +00:00
|
|
|
rev->abbrev = DEFAULT_ABBREV;
|
|
|
|
rev->commit_format = CMIT_FMT_DEFAULT;
|
|
|
|
rev->verbose_header = 1;
|
2006-11-23 09:36:33 +00:00
|
|
|
rev->show_root_diff = default_show_root;
|
2006-04-21 17:27:34 +00:00
|
|
|
argc = setup_revisions(argc, argv, rev, "HEAD");
|
2006-06-25 12:39:35 +00:00
|
|
|
if (rev->diffopt.pickaxe || rev->diffopt.filter)
|
|
|
|
rev->always_show_header = 0;
|
2006-12-25 19:48:35 +00:00
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
const char *arg = argv[i];
|
2007-05-16 11:15:07 +00:00
|
|
|
if (!strcmp(arg, "--decorate")) {
|
2007-04-16 23:05:10 +00:00
|
|
|
if (!decorate)
|
|
|
|
for_each_ref(add_ref_decoration, NULL);
|
|
|
|
decorate = 1;
|
|
|
|
} else
|
2006-12-25 19:48:35 +00:00
|
|
|
die("unrecognized argument: %s", arg);
|
|
|
|
}
|
2006-06-25 12:39:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int cmd_log_walk(struct rev_info *rev)
|
|
|
|
{
|
|
|
|
struct commit *commit;
|
2006-04-21 17:27:34 +00:00
|
|
|
|
|
|
|
prepare_revision_walk(rev);
|
|
|
|
while ((commit = get_revision(rev)) != NULL) {
|
|
|
|
log_tree_commit(rev, commit);
|
2007-01-20 21:28:16 +00:00
|
|
|
if (!rev->reflog_info) {
|
|
|
|
/* we allow cycles in reflog ancestry */
|
|
|
|
free(commit->buffer);
|
|
|
|
commit->buffer = NULL;
|
|
|
|
}
|
2006-06-18 01:47:58 +00:00
|
|
|
free_commit_list(commit->parents);
|
|
|
|
commit->parents = NULL;
|
2006-04-21 17:27:34 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-11-23 09:36:33 +00:00
|
|
|
static int git_log_config(const char *var, const char *value)
|
|
|
|
{
|
|
|
|
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 05:44:25 +00:00
|
|
|
int cmd_whatchanged(int argc, const char **argv, const char *prefix)
|
2006-04-21 17:27:34 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
|
|
|
|
2006-11-23 09:36:33 +00:00
|
|
|
git_config(git_log_config);
|
2006-07-29 04:21:48 +00:00
|
|
|
init_revisions(&rev, prefix);
|
2006-04-21 17:27:34 +00:00
|
|
|
rev.diff = 1;
|
|
|
|
rev.diffopt.recursive = 1;
|
2006-06-11 17:57:35 +00:00
|
|
|
rev.simplify_history = 0;
|
2006-07-29 05:44:25 +00:00
|
|
|
cmd_log_init(argc, argv, prefix, &rev);
|
2006-06-25 12:39:35 +00:00
|
|
|
if (!rev.diffopt.output_format)
|
|
|
|
rev.diffopt.output_format = DIFF_FORMAT_RAW;
|
|
|
|
return cmd_log_walk(&rev);
|
2006-04-21 17:27:34 +00:00
|
|
|
}
|
|
|
|
|
2006-12-14 10:31:05 +00:00
|
|
|
static int show_object(const unsigned char *sha1, int suppress_header)
|
|
|
|
{
|
|
|
|
unsigned long size;
|
2007-02-26 19:55:59 +00:00
|
|
|
enum object_type type;
|
|
|
|
char *buf = read_sha1_file(sha1, &type, &size);
|
2006-12-14 10:31:05 +00:00
|
|
|
int offset = 0;
|
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
return error("Could not read object %s", sha1_to_hex(sha1));
|
|
|
|
|
|
|
|
if (suppress_header)
|
|
|
|
while (offset < size && buf[offset++] != '\n') {
|
|
|
|
int new_offset = offset;
|
|
|
|
while (new_offset < size && buf[new_offset++] != '\n')
|
|
|
|
; /* do nothing */
|
|
|
|
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 05:44:25 +00:00
|
|
|
int cmd_show(int argc, const char **argv, const char *prefix)
|
2006-04-21 17:27:34 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
2006-12-14 10:31:05 +00:00
|
|
|
struct object_array_entry *objects;
|
|
|
|
int i, count, ret = 0;
|
2006-04-21 17:27:34 +00:00
|
|
|
|
2006-11-23 09:36:33 +00:00
|
|
|
git_config(git_log_config);
|
2006-07-29 04:21:48 +00:00
|
|
|
init_revisions(&rev, prefix);
|
2006-04-21 17:27:34 +00:00
|
|
|
rev.diff = 1;
|
|
|
|
rev.diffopt.recursive = 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 05:44:25 +00:00
|
|
|
cmd_log_init(argc, argv, prefix, &rev);
|
2006-12-14 10:31:05 +00: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:
|
|
|
|
ret = show_object(o->sha1, 0);
|
|
|
|
break;
|
|
|
|
case OBJ_TAG: {
|
|
|
|
struct tag *t = (struct tag *)o;
|
|
|
|
|
|
|
|
printf("%stag %s%s\n\n",
|
|
|
|
diff_get_color(rev.diffopt.color_diff,
|
|
|
|
DIFF_COMMIT),
|
|
|
|
t->tag,
|
|
|
|
diff_get_color(rev.diffopt.color_diff,
|
|
|
|
DIFF_RESET));
|
|
|
|
ret = show_object(o->sha1, 1);
|
|
|
|
objects[i].item = (struct object *)t->tagged;
|
|
|
|
i--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case OBJ_TREE:
|
|
|
|
printf("%stree %s%s\n\n",
|
|
|
|
diff_get_color(rev.diffopt.color_diff,
|
|
|
|
DIFF_COMMIT),
|
|
|
|
name,
|
|
|
|
diff_get_color(rev.diffopt.color_diff,
|
|
|
|
DIFF_RESET));
|
|
|
|
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 17:27:34 +00:00
|
|
|
}
|
|
|
|
|
2007-02-08 17:51:56 +00: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);
|
|
|
|
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;
|
|
|
|
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 05:44:25 +00:00
|
|
|
int cmd_log(int argc, const char **argv, const char *prefix)
|
2006-04-21 17:27:34 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
|
|
|
|
2006-11-23 09:36:33 +00:00
|
|
|
git_config(git_log_config);
|
2006-07-29 04:21:48 +00:00
|
|
|
init_revisions(&rev, prefix);
|
2006-04-21 17:27:34 +00:00
|
|
|
rev.always_show_header = 1;
|
2006-07-29 05:44:25 +00:00
|
|
|
cmd_log_init(argc, argv, prefix, &rev);
|
2006-06-25 12:39:35 +00:00
|
|
|
return cmd_log_walk(&rev);
|
2006-04-21 17:27:34 +00:00
|
|
|
}
|
2006-04-21 20:19:58 +00:00
|
|
|
|
2007-02-23 22:27:58 +00:00
|
|
|
/* format-patch */
|
|
|
|
#define FORMAT_PATCH_NAME_MAX 64
|
|
|
|
|
2006-05-04 23:16:40 +00:00
|
|
|
static int istitlechar(char c)
|
|
|
|
{
|
|
|
|
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
|
|
|
|
(c >= '0' && c <= '9') || c == '.' || c == '_';
|
|
|
|
}
|
|
|
|
|
2006-06-02 13:21:17 +00:00
|
|
|
static char *extra_headers = NULL;
|
|
|
|
static int extra_headers_size = 0;
|
2007-01-17 23:03:39 +00:00
|
|
|
static const char *fmt_patch_suffix = ".patch";
|
2006-06-02 13:21:17 +00:00
|
|
|
|
|
|
|
static int git_format_config(const char *var, const char *value)
|
|
|
|
{
|
|
|
|
if (!strcmp(var, "format.headers")) {
|
2007-01-17 19:13:02 +00:00
|
|
|
int len;
|
|
|
|
|
|
|
|
if (!value)
|
|
|
|
die("format.headers without value");
|
|
|
|
len = strlen(value);
|
2006-06-02 13:21:17 +00:00
|
|
|
extra_headers_size += len + 1;
|
2006-08-26 14:16:18 +00:00
|
|
|
extra_headers = xrealloc(extra_headers, extra_headers_size);
|
2006-06-02 13:21:17 +00:00
|
|
|
extra_headers[extra_headers_size - len - 1] = 0;
|
|
|
|
strcat(extra_headers, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-01-17 19:12:03 +00:00
|
|
|
if (!strcmp(var, "format.suffix")) {
|
|
|
|
if (!value)
|
|
|
|
die("format.suffix without value");
|
|
|
|
fmt_patch_suffix = xstrdup(value);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-12-13 09:13:28 +00:00
|
|
|
if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff")) {
|
2006-07-09 06:28:21 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2006-11-23 09:36:33 +00:00
|
|
|
return git_log_config(var, value);
|
2006-06-02 13:21:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-05-05 01:33:05 +00:00
|
|
|
static FILE *realstdout = NULL;
|
2006-06-06 15:46:23 +00:00
|
|
|
static const char *output_directory = NULL;
|
2006-05-05 01:33:05 +00:00
|
|
|
|
2007-06-05 20:06:53 +00:00
|
|
|
static int reopen_stdout(struct commit *commit, int nr, int keep_subject,
|
|
|
|
int numbered_files)
|
2006-05-04 23:16:40 +00:00
|
|
|
{
|
2007-02-23 22:27:58 +00:00
|
|
|
char filename[PATH_MAX];
|
2006-05-04 23:16:40 +00:00
|
|
|
char *sol;
|
2006-05-05 01:33:32 +00:00
|
|
|
int len = 0;
|
2007-02-23 22:27:58 +00:00
|
|
|
int suffix_len = strlen(fmt_patch_suffix) + 1;
|
2006-05-04 23:16:40 +00:00
|
|
|
|
2006-05-05 01:33:32 +00:00
|
|
|
if (output_directory) {
|
2007-02-23 22:27:58 +00:00
|
|
|
if (strlen(output_directory) >=
|
|
|
|
sizeof(filename) - FORMAT_PATCH_NAME_MAX - suffix_len)
|
|
|
|
return error("name of output directory is too long");
|
|
|
|
strlcpy(filename, output_directory, sizeof(filename) - suffix_len);
|
2006-05-05 01:33:32 +00:00
|
|
|
len = strlen(filename);
|
|
|
|
if (filename[len - 1] != '/')
|
|
|
|
filename[len++] = '/';
|
|
|
|
}
|
2006-05-04 23:16:40 +00:00
|
|
|
|
2007-06-05 20:06:53 +00:00
|
|
|
if (numbered_files) {
|
|
|
|
sprintf(filename + len, "%d", nr);
|
|
|
|
len = strlen(filename);
|
2006-05-04 23:16:40 +00:00
|
|
|
|
2007-06-05 20:06:53 +00:00
|
|
|
} else {
|
|
|
|
sprintf(filename + len, "%04d", nr);
|
|
|
|
len = strlen(filename);
|
|
|
|
|
|
|
|
sol = strstr(commit->buffer, "\n\n");
|
|
|
|
if (sol) {
|
|
|
|
int j, space = 1;
|
|
|
|
|
|
|
|
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;
|
2006-05-04 23:16:40 +00:00
|
|
|
}
|
2007-06-05 20:06:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2006-05-04 23:16:40 +00:00
|
|
|
}
|
2007-06-05 20:06:53 +00:00
|
|
|
if (len + suffix_len >= sizeof(filename))
|
|
|
|
return error("Patch pathname too long");
|
|
|
|
strcpy(filename + len, fmt_patch_suffix);
|
2006-05-04 23:16:40 +00:00
|
|
|
}
|
2007-06-05 20:06:53 +00:00
|
|
|
|
2006-05-05 01:33:05 +00:00
|
|
|
fprintf(realstdout, "%s\n", filename);
|
2007-02-23 22:27:58 +00:00
|
|
|
if (freopen(filename, "w", stdout) == NULL)
|
|
|
|
return error("Cannot open patch file %s",filename);
|
|
|
|
|
2007-06-05 20:06:53 +00:00
|
|
|
return 0;
|
2006-05-04 23:16:40 +00:00
|
|
|
}
|
|
|
|
|
2007-04-10 00:01:27 +00:00
|
|
|
static void get_patch_ids(struct rev_info *rev, struct patch_ids *ids, const char *prefix)
|
2006-06-25 01:52:01 +00: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 00:01:27 +00:00
|
|
|
init_patch_ids(ids);
|
2006-06-25 01:52:01 +00:00
|
|
|
|
|
|
|
/* given a range a..b get all patch ids for b..a */
|
2006-07-29 04:21:48 +00:00
|
|
|
init_revisions(&check_rev, prefix);
|
2006-06-25 01:52:01 +00:00
|
|
|
o1->flags ^= UNINTERESTING;
|
|
|
|
o2->flags ^= UNINTERESTING;
|
|
|
|
add_pending_object(&check_rev, o1, "o1");
|
|
|
|
add_pending_object(&check_rev, o2, "o2");
|
|
|
|
prepare_revision_walk(&check_rev);
|
|
|
|
|
|
|
|
while ((commit = get_revision(&check_rev)) != NULL) {
|
|
|
|
/* ignore merges */
|
|
|
|
if (commit->parents && commit->parents->next)
|
|
|
|
continue;
|
|
|
|
|
2007-04-10 00:01:27 +00:00
|
|
|
add_commit_patch_id(commit, ids);
|
2006-06-25 01:52:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* reset for next revision walk */
|
2006-06-27 20:38:04 +00:00
|
|
|
clear_commit_marks((struct commit *)o1,
|
|
|
|
SEEN | UNINTERESTING | SHOWN | ADDED);
|
|
|
|
clear_commit_marks((struct commit *)o2,
|
|
|
|
SEEN | UNINTERESTING | SHOWN | ADDED);
|
2006-06-25 01:52:01 +00:00
|
|
|
o1->flags = flags1;
|
|
|
|
o2->flags = flags2;
|
|
|
|
}
|
|
|
|
|
2006-07-15 00:48:51 +00:00
|
|
|
static void gen_message_id(char *dest, unsigned int length, char *base)
|
|
|
|
{
|
Allow non-developer to clone, checkout and fetch more easily.
The code that uses committer_info() in reflog can barf and die
whenever it is asked to update a ref. And I do not think
calling ignore_missing_committer_name() upfront like recent
receive-pack did in the aplication is a reasonable workaround.
What the patch does.
- git_committer_info() takes one parameter. It used to be "if
this is true, then die() if the name is not available due to
bad GECOS, otherwise issue a warning once but leave the name
empty". The reason was because we wanted to prevent bad
commits from being made by git-commit-tree (and its
callers). The value 0 is only used by "git var -l".
Now it takes -1, 0 or 1. When set to -1, it does not
complain but uses the pw->pw_name when name is not
available. Existing 0 and 1 values mean the same thing as
they used to mean before. 0 means issue warnings and leave
it empty, 1 means barf and die.
- ignore_missing_committer_name() and its existing caller
(receive-pack, to set the reflog) have been removed.
- git-format-patch, to come up with the phoney message ID when
asked to thread, now passes -1 to git_committer_info(). This
codepath uses only the e-mail part, ignoring the name. It
used to barf and die. The other call in the same program
when asked to add signed-off-by line based on committer
identity still passes 1 to make sure it barfs instead of
adding a bogus s-o-b line.
- log_ref_write in refs.c, to come up with the name to record
who initiated the ref update in the reflog, passes -1. It
used to barf and die.
The last change means that git-update-ref, git-branch, and
commit walker backends can now be used in a repository with
reflog by somebody who does not have the user identity required
to make a commit. They all used to barf and die.
I've run tests and all of them seem to pass, and also tried "git
clone" as a user whose GECOS is empty -- git clone works again
now (it was broken when reflog was enabled by default).
But this definitely needs extra sets of eyeballs.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-01-26 03:05:01 +00:00
|
|
|
const char *committer = git_committer_info(-1);
|
2006-07-15 00:48:51 +00:00
|
|
|
const char *email_start = strrchr(committer, '<');
|
|
|
|
const char *email_end = strrchr(committer, '>');
|
|
|
|
if(!email_start || !email_end || email_start > email_end - 1)
|
|
|
|
die("Could not extract email from committer identity.");
|
2006-07-15 05:47:53 +00:00
|
|
|
snprintf(dest, length, "%s.%lu.git.%.*s", base,
|
|
|
|
(unsigned long) time(NULL),
|
|
|
|
(int)(email_end - email_start - 1), email_start + 1);
|
2006-07-15 00:48:51 +00:00
|
|
|
}
|
|
|
|
|
2006-07-29 05:44:25 +00:00
|
|
|
int cmd_format_patch(int argc, const char **argv, const char *prefix)
|
2006-04-21 20:19:58 +00:00
|
|
|
{
|
|
|
|
struct commit *commit;
|
|
|
|
struct commit **list = NULL;
|
|
|
|
struct rev_info rev;
|
2006-05-05 01:33:32 +00:00
|
|
|
int nr = 0, total, i, j;
|
2006-05-04 23:16:40 +00:00
|
|
|
int use_stdout = 0;
|
2006-05-05 02:30:52 +00:00
|
|
|
int numbered = 0;
|
2006-05-25 21:55:11 +00:00
|
|
|
int start_number = -1;
|
2006-05-05 02:31:29 +00:00
|
|
|
int keep_subject = 0;
|
2007-06-05 20:06:53 +00:00
|
|
|
int numbered_files = 0; /* _just_ numbers */
|
2007-04-11 23:58:07 +00:00
|
|
|
int subject_prefix = 0;
|
2006-06-25 01:52:01 +00:00
|
|
|
int ignore_if_in_upstream = 0;
|
2006-07-15 00:49:04 +00:00
|
|
|
int thread = 0;
|
2006-07-15 05:47:53 +00:00
|
|
|
const char *in_reply_to = NULL;
|
2007-04-10 00:01:27 +00:00
|
|
|
struct patch_ids ids;
|
2006-05-31 22:11:49 +00:00
|
|
|
char *add_signoff = NULL;
|
2006-07-15 00:48:51 +00:00
|
|
|
char message_id[1024];
|
|
|
|
char ref_message_id[1024];
|
2006-04-21 20:19:58 +00:00
|
|
|
|
2006-07-07 10:10:45 +00:00
|
|
|
git_config(git_format_config);
|
2006-07-29 04:21:48 +00:00
|
|
|
init_revisions(&rev, prefix);
|
2006-04-21 20:19:58 +00:00
|
|
|
rev.commit_format = CMIT_FMT_EMAIL;
|
|
|
|
rev.verbose_header = 1;
|
|
|
|
rev.diff = 1;
|
|
|
|
rev.combine_merges = 0;
|
|
|
|
rev.ignore_merges = 1;
|
2006-06-29 07:18:52 +00:00
|
|
|
rev.diffopt.msg_sep = "";
|
|
|
|
rev.diffopt.recursive = 1;
|
2006-04-21 20:19:58 +00:00
|
|
|
|
2006-06-02 13:21:17 +00:00
|
|
|
rev.extra_headers = extra_headers;
|
|
|
|
|
2006-05-05 01:33:32 +00:00
|
|
|
/*
|
|
|
|
* Parse the arguments before setup_revisions(), or something
|
2007-05-14 14:44:51 +00:00
|
|
|
* like "git format-patch -o a123 HEAD^.." may fail; a123 is
|
2006-05-05 01:33:32 +00:00
|
|
|
* possibly a valid SHA1.
|
|
|
|
*/
|
|
|
|
for (i = 1, j = 1; i < argc; i++) {
|
|
|
|
if (!strcmp(argv[i], "--stdout"))
|
2006-05-04 23:16:40 +00:00
|
|
|
use_stdout = 1;
|
2006-05-05 02:30:52 +00:00
|
|
|
else if (!strcmp(argv[i], "-n") ||
|
|
|
|
!strcmp(argv[i], "--numbered"))
|
|
|
|
numbered = 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(argv[i], "--start-number="))
|
2006-05-25 21:55:11 +00:00
|
|
|
start_number = strtol(argv[i] + 15, NULL, 10);
|
2007-06-05 20:06:53 +00:00
|
|
|
else if (!strcmp(argv[i], "--numbered-files"))
|
|
|
|
numbered_files = 1;
|
2006-05-25 21:55:11 +00: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-05-31 22:11:49 +00:00
|
|
|
}
|
|
|
|
else if (!strcmp(argv[i], "-k") ||
|
2006-05-05 02:31:29 +00:00
|
|
|
!strcmp(argv[i], "--keep-subject")) {
|
|
|
|
keep_subject = 1;
|
|
|
|
rev.total = -1;
|
2006-05-31 22:11:49 +00:00
|
|
|
}
|
2006-06-06 15:46:23 +00:00
|
|
|
else if (!strcmp(argv[i], "--output-directory") ||
|
|
|
|
!strcmp(argv[i], "-o")) {
|
2006-05-05 01:33:32 +00:00
|
|
|
i++;
|
2006-06-06 15:46:23 +00:00
|
|
|
if (argc <= i)
|
|
|
|
die("Which directory?");
|
|
|
|
if (output_directory)
|
|
|
|
die("Two output directories?");
|
|
|
|
output_directory = argv[i];
|
2006-05-20 13:40:29 +00:00
|
|
|
}
|
2006-05-31 22:11:49 +00:00
|
|
|
else if (!strcmp(argv[i], "--signoff") ||
|
|
|
|
!strcmp(argv[i], "-s")) {
|
2006-06-12 19:31:38 +00:00
|
|
|
const char *committer;
|
|
|
|
const char *endpos;
|
|
|
|
committer = git_committer_info(1);
|
|
|
|
endpos = strchr(committer, '>');
|
2006-05-31 22:11:49 +00:00
|
|
|
if (!endpos)
|
|
|
|
die("bogos committer info %s\n", committer);
|
|
|
|
add_signoff = xmalloc(endpos - committer + 2);
|
|
|
|
memcpy(add_signoff, committer, endpos - committer + 1);
|
|
|
|
add_signoff[endpos - committer + 1] = 0;
|
|
|
|
}
|
2007-03-03 23:12:06 +00:00
|
|
|
else if (!strcmp(argv[i], "--attach")) {
|
2006-05-20 13:40:29 +00:00
|
|
|
rev.mime_boundary = git_version_string;
|
2007-03-03 23:12:06 +00: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 13:40:29 +00:00
|
|
|
rev.mime_boundary = argv[i] + 9;
|
2007-03-03 23:12:06 +00:00
|
|
|
rev.no_inline = 0;
|
|
|
|
}
|
2006-06-25 01:52:01 +00:00
|
|
|
else if (!strcmp(argv[i], "--ignore-if-in-upstream"))
|
|
|
|
ignore_if_in_upstream = 1;
|
2006-07-15 00:49:04 +00: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 09:53:29 +00:00
|
|
|
else if (!prefixcmp(argv[i], "--in-reply-to="))
|
2006-07-15 00:49:08 +00: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-11 23:58:07 +00: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 19:12:03 +00:00
|
|
|
fmt_patch_suffix = argv[i] + 9;
|
2006-05-20 13:40:29 +00:00
|
|
|
else
|
2006-05-05 01:33:32 +00:00
|
|
|
argv[j++] = argv[i];
|
2006-05-04 23:16:40 +00:00
|
|
|
}
|
2006-05-05 01:33:32 +00:00
|
|
|
argc = j;
|
|
|
|
|
2006-05-26 18:30:49 +00:00
|
|
|
if (start_number < 0)
|
2006-05-25 21:55:11 +00:00
|
|
|
start_number = 1;
|
2006-05-28 16:23:29 +00:00
|
|
|
if (numbered && keep_subject)
|
2006-05-05 02:31:29 +00:00
|
|
|
die ("-n and -k are mutually exclusive.");
|
2007-04-11 23:58:07 +00:00
|
|
|
if (keep_subject && subject_prefix)
|
|
|
|
die ("--subject-prefix and -k are mutually exclusive.");
|
2007-06-05 20:06:53 +00:00
|
|
|
if (numbered_files && use_stdout)
|
|
|
|
die ("--numbered-files and --stdout are mutually exclusive.");
|
2006-05-05 02:31:29 +00:00
|
|
|
|
2006-05-05 01:33:32 +00:00
|
|
|
argc = setup_revisions(argc, argv, &rev, "HEAD");
|
|
|
|
if (argc > 1)
|
|
|
|
die ("unrecognized argument: %s", argv[1]);
|
2006-05-04 23:16:40 +00:00
|
|
|
|
2006-06-24 17:24:14 +00:00
|
|
|
if (!rev.diffopt.output_format)
|
2007-01-17 21:51:44 +00:00
|
|
|
rev.diffopt.output_format = DIFF_FORMAT_DIFFSTAT | DIFF_FORMAT_SUMMARY | DIFF_FORMAT_PATCH;
|
2006-06-24 17:24:14 +00:00
|
|
|
|
2007-01-17 22:32:52 +00:00
|
|
|
if (!rev.diffopt.text)
|
|
|
|
rev.diffopt.binary = 1;
|
|
|
|
|
2007-01-23 03:38:28 +00:00
|
|
|
if (!output_directory && !use_stdout)
|
2006-09-28 19:55:35 +00:00
|
|
|
output_directory = prefix;
|
|
|
|
|
2006-06-06 15:46:23 +00: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 00:42:35 +00:00
|
|
|
if (rev.pending.nr == 1) {
|
2007-01-17 21:35:13 +00:00
|
|
|
if (rev.max_count < 0) {
|
|
|
|
rev.pending.objects[0].item->flags |= UNINTERESTING;
|
|
|
|
add_head(&rev);
|
|
|
|
}
|
|
|
|
/* Otherwise, it is "format-patch -22 HEAD", and
|
|
|
|
* get_revision() would return only the specified count.
|
|
|
|
*/
|
2006-05-06 20:56:38 +00:00
|
|
|
}
|
|
|
|
|
2006-06-25 01:52:01 +00:00
|
|
|
if (ignore_if_in_upstream)
|
2007-04-10 00:01:27 +00:00
|
|
|
get_patch_ids(&rev, &ids, prefix);
|
2006-06-25 01:52:01 +00:00
|
|
|
|
2006-05-05 01:33:05 +00:00
|
|
|
if (!use_stdout)
|
|
|
|
realstdout = fdopen(dup(1), "w");
|
|
|
|
|
2006-04-21 20:19:58 +00:00
|
|
|
prepare_revision_walk(&rev);
|
|
|
|
while ((commit = get_revision(&rev)) != NULL) {
|
2006-05-04 23:16:40 +00:00
|
|
|
/* ignore merges */
|
|
|
|
if (commit->parents && commit->parents->next)
|
|
|
|
continue;
|
2006-06-25 01:52:01 +00:00
|
|
|
|
|
|
|
if (ignore_if_in_upstream &&
|
2007-04-10 00:01:27 +00:00
|
|
|
has_commit_patch_id(commit, &ids))
|
2006-06-25 01:52:01 +00:00
|
|
|
continue;
|
|
|
|
|
2006-04-21 20:19:58 +00:00
|
|
|
nr++;
|
2006-08-26 14:16:18 +00:00
|
|
|
list = xrealloc(list, nr * sizeof(list[0]));
|
2006-04-21 20:19:58 +00:00
|
|
|
list[nr - 1] = commit;
|
|
|
|
}
|
2006-05-04 23:16:40 +00:00
|
|
|
total = nr;
|
2006-05-05 02:30:52 +00:00
|
|
|
if (numbered)
|
2006-05-25 21:55:11 +00:00
|
|
|
rev.total = total + start_number - 1;
|
2006-05-31 22:11:49 +00:00
|
|
|
rev.add_signoff = add_signoff;
|
2006-07-15 00:49:08 +00:00
|
|
|
rev.ref_message_id = in_reply_to;
|
2006-04-21 20:19:58 +00:00
|
|
|
while (0 <= --nr) {
|
|
|
|
int shown;
|
|
|
|
commit = list[nr];
|
2006-05-26 18:30:49 +00:00
|
|
|
rev.nr = total - nr + (start_number - 1);
|
2006-07-15 00:48:51 +00:00
|
|
|
/* Make the second and subsequent mails replies to the first */
|
2006-07-15 00:49:04 +00:00
|
|
|
if (thread) {
|
|
|
|
if (nr == (total - 2)) {
|
|
|
|
strncpy(ref_message_id, message_id,
|
|
|
|
sizeof(ref_message_id));
|
|
|
|
ref_message_id[sizeof(ref_message_id)-1]='\0';
|
|
|
|
rev.ref_message_id = ref_message_id;
|
|
|
|
}
|
|
|
|
gen_message_id(message_id, sizeof(message_id),
|
|
|
|
sha1_to_hex(commit->object.sha1));
|
|
|
|
rev.message_id = message_id;
|
2006-07-15 00:48:51 +00:00
|
|
|
}
|
2006-05-04 23:16:40 +00:00
|
|
|
if (!use_stdout)
|
2007-06-05 20:06:53 +00:00
|
|
|
if (reopen_stdout(commit, rev.nr, keep_subject,
|
|
|
|
numbered_files))
|
2007-02-23 22:27:58 +00:00
|
|
|
die("Failed to create output files");
|
2006-04-21 20:19:58 +00:00
|
|
|
shown = log_tree_commit(&rev, commit);
|
|
|
|
free(commit->buffer);
|
|
|
|
commit->buffer = NULL;
|
2006-05-26 18:30:49 +00: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 13:40:29 +00: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-04 23:16:40 +00:00
|
|
|
if (!use_stdout)
|
|
|
|
fclose(stdout);
|
2006-04-21 20:19:58 +00:00
|
|
|
}
|
|
|
|
free(list);
|
2007-04-10 00:01:27 +00:00
|
|
|
if (ignore_if_in_upstream)
|
|
|
|
free_patch_ids(&ids);
|
2006-04-21 20:19:58 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-23 23:01:57 +00: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 00:01:27 +00:00
|
|
|
struct patch_ids ids;
|
2006-10-23 23:01:57 +00: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;
|
|
|
|
revs.diffopt.recursive = 1;
|
|
|
|
|
|
|
|
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 00:01:27 +00:00
|
|
|
get_patch_ids(&revs, &ids, prefix);
|
2006-10-23 23:01:57 +00:00
|
|
|
|
|
|
|
if (limit && add_pending_commit(limit, &revs, UNINTERESTING))
|
|
|
|
die("Unknown commit %s", limit);
|
|
|
|
|
|
|
|
/* reverse the list of commits */
|
|
|
|
prepare_revision_walk(&revs);
|
|
|
|
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 00:01:27 +00:00
|
|
|
if (has_commit_patch_id(commit, &ids))
|
2006-10-23 23:01:57 +00:00
|
|
|
sign = '-';
|
|
|
|
|
|
|
|
if (verbose) {
|
2007-06-11 07:34:54 +00:00
|
|
|
char *buf = NULL;
|
|
|
|
unsigned long buflen = 0;
|
2006-10-23 23:01:57 +00:00
|
|
|
pretty_print_commit(CMIT_FMT_ONELINE, commit, ~0,
|
2007-06-11 07:34:54 +00:00
|
|
|
&buf, &buflen, 0, NULL, NULL, 0);
|
2006-10-23 23:01:57 +00:00
|
|
|
printf("%c %s %s\n", sign,
|
|
|
|
sha1_to_hex(commit->object.sha1), buf);
|
2007-06-11 07:34:54 +00:00
|
|
|
free(buf);
|
2006-10-23 23:01:57 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
printf("%c %s\n", sign,
|
|
|
|
sha1_to_hex(commit->object.sha1));
|
|
|
|
}
|
|
|
|
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
|
2007-04-10 00:01:27 +00:00
|
|
|
free_patch_ids(&ids);
|
2006-10-23 23:01:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|