2006-01-07 09:33:54 +00:00
|
|
|
#include "cache.h"
|
2005-05-18 23:14:22 +00:00
|
|
|
#include "tag.h"
|
2005-04-18 18:39:48 +00:00
|
|
|
#include "commit.h"
|
2006-10-30 19:09:06 +00:00
|
|
|
#include "pkt-line.h"
|
2006-12-25 19:48:35 +00:00
|
|
|
#include "utf8.h"
|
2007-04-09 09:34:05 +00:00
|
|
|
#include "diff.h"
|
|
|
|
#include "revision.h"
|
2009-10-09 10:21:57 +00:00
|
|
|
#include "notes.h"
|
2005-04-18 18:39:48 +00:00
|
|
|
|
[PATCH] Avoid wasting memory in git-rev-list
As pointed out on the list, git-rev-list can use a lot of memory.
One low-hanging fruit is to free the commit buffer for commits that we
parse. By default, parse_commit() will save away the buffer, since a lot
of cases do want it, and re-reading it continually would be unnecessary.
However, in many cases the buffer isn't actually necessary and saving it
just wastes memory.
We could just free the buffer ourselves, but especially in git-rev-list,
we actually end up using the helper functions that automatically add
parent commits to the commit lists, so we don't actually control the
commit parsing directly.
Instead, just make this behaviour of "parse_commit()" a global flag.
Maybe this is a bit tasteless, but it's very simple, and it makes a
noticable difference in memory usage.
Before the change:
[torvalds@g5 linux]$ /usr/bin/time git-rev-list v2.6.12..HEAD > /dev/null
0.26user 0.02system 0:00.28elapsed 99%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+3714minor)pagefaults 0swaps
after the change:
[torvalds@g5 linux]$ /usr/bin/time git-rev-list v2.6.12..HEAD > /dev/null
0.26user 0.00system 0:00.27elapsed 100%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+2433minor)pagefaults 0swaps
note how the minor faults have decreased from 3714 pages to 2433 pages.
That's all due to the fewer anonymous pages allocated to hold the comment
buffers and their metadata.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-09-15 21:43:17 +00:00
|
|
|
int save_commit_buffer = 1;
|
|
|
|
|
2005-04-18 18:39:48 +00:00
|
|
|
const char *commit_type = "commit";
|
|
|
|
|
2005-08-21 09:51:10 +00:00
|
|
|
static struct commit *check_commit(struct object *obj,
|
|
|
|
const unsigned char *sha1,
|
|
|
|
int quiet)
|
2005-05-18 23:14:22 +00:00
|
|
|
{
|
2006-07-12 03:45:31 +00:00
|
|
|
if (obj->type != OBJ_COMMIT) {
|
2005-08-21 09:51:10 +00:00
|
|
|
if (!quiet)
|
|
|
|
error("Object %s is a %s, not a commit",
|
Shrink "struct object" a bit
This shrinks "struct object" by a small amount, by getting rid of the
"struct type *" pointer and replacing it with a 3-bit bitfield instead.
In addition, we merge the bitfields and the "flags" field, which
incidentally should also remove a useless 4-byte padding from the object
when in 64-bit mode.
Now, our "struct object" is still too damn large, but it's now less
obviously bloated, and of the remaining fields, only the "util" (which is
not used by most things) is clearly something that should be eventually
discarded.
This shrinks the "git-rev-list --all" memory use by about 2.5% on the
kernel archive (and, perhaps more importantly, on the larger mozilla
archive). That may not sound like much, but I suspect it's more on a
64-bit platform.
There are other remaining inefficiencies (the parent lists, for example,
probably have horrible malloc overhead), but this was pretty obvious.
Most of the patch is just changing the comparison of the "type" pointer
from one of the constant string pointers to the appropriate new TYPE_xxx
small integer constant.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-14 23:45:13 +00:00
|
|
|
sha1_to_hex(sha1), typename(obj->type));
|
2005-05-18 23:14:22 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return (struct commit *) obj;
|
|
|
|
}
|
|
|
|
|
2005-08-21 09:51:10 +00:00
|
|
|
struct commit *lookup_commit_reference_gently(const unsigned char *sha1,
|
|
|
|
int quiet)
|
2005-05-18 23:14:22 +00:00
|
|
|
{
|
2005-11-02 23:19:13 +00:00
|
|
|
struct object *obj = deref_tag(parse_object(sha1), NULL, 0);
|
2005-05-18 23:14:22 +00:00
|
|
|
|
|
|
|
if (!obj)
|
|
|
|
return NULL;
|
2005-08-21 09:51:10 +00:00
|
|
|
return check_commit(obj, sha1, quiet);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct commit *lookup_commit_reference(const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
return lookup_commit_reference_gently(sha1, 0);
|
2005-05-18 23:14:22 +00:00
|
|
|
}
|
|
|
|
|
2011-09-17 11:57:45 +00:00
|
|
|
struct commit *lookup_commit_or_die(const unsigned char *sha1, const char *ref_name)
|
|
|
|
{
|
|
|
|
struct commit *c = lookup_commit_reference(sha1);
|
|
|
|
if (!c)
|
|
|
|
die(_("could not parse %s"), ref_name);
|
|
|
|
if (hashcmp(sha1, c->object.sha1)) {
|
|
|
|
warning(_("%s %s is not a commit!"),
|
|
|
|
ref_name, sha1_to_hex(sha1));
|
|
|
|
}
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2005-06-03 15:05:39 +00:00
|
|
|
struct commit *lookup_commit(const unsigned char *sha1)
|
2005-04-18 18:39:48 +00:00
|
|
|
{
|
|
|
|
struct object *obj = lookup_object(sha1);
|
2007-04-17 05:11:43 +00:00
|
|
|
if (!obj)
|
|
|
|
return create_object(sha1, OBJ_COMMIT, alloc_commit_node());
|
2005-05-20 20:59:17 +00:00
|
|
|
if (!obj->type)
|
2006-07-12 03:45:31 +00:00
|
|
|
obj->type = OBJ_COMMIT;
|
2005-08-21 09:51:10 +00:00
|
|
|
return check_commit(obj, sha1, 0);
|
2005-04-18 18:39:48 +00:00
|
|
|
}
|
|
|
|
|
2010-11-02 19:59:07 +00:00
|
|
|
struct commit *lookup_commit_reference_by_name(const char *name)
|
|
|
|
{
|
|
|
|
unsigned char sha1[20];
|
|
|
|
struct commit *commit;
|
|
|
|
|
|
|
|
if (get_sha1(name, sha1))
|
|
|
|
return NULL;
|
|
|
|
commit = lookup_commit_reference(sha1);
|
|
|
|
if (!commit || parse_commit(commit))
|
|
|
|
return NULL;
|
|
|
|
return commit;
|
|
|
|
}
|
|
|
|
|
2008-01-19 17:35:23 +00:00
|
|
|
static unsigned long parse_commit_date(const char *buf, const char *tail)
|
2005-04-18 18:39:48 +00:00
|
|
|
{
|
2008-01-19 17:35:23 +00:00
|
|
|
const char *dateptr;
|
2005-04-18 18:39:48 +00:00
|
|
|
|
2008-01-19 17:35:23 +00:00
|
|
|
if (buf + 6 >= tail)
|
|
|
|
return 0;
|
2005-04-18 18:39:48 +00:00
|
|
|
if (memcmp(buf, "author", 6))
|
|
|
|
return 0;
|
2008-01-19 17:35:23 +00:00
|
|
|
while (buf < tail && *buf++ != '\n')
|
2005-04-18 18:39:48 +00:00
|
|
|
/* nada */;
|
2008-01-19 17:35:23 +00:00
|
|
|
if (buf + 9 >= tail)
|
|
|
|
return 0;
|
2005-04-18 18:39:48 +00:00
|
|
|
if (memcmp(buf, "committer", 9))
|
|
|
|
return 0;
|
2008-01-19 17:35:23 +00:00
|
|
|
while (buf < tail && *buf++ != '>')
|
2005-04-18 18:39:48 +00:00
|
|
|
/* nada */;
|
2008-01-19 17:35:23 +00:00
|
|
|
if (buf >= tail)
|
|
|
|
return 0;
|
|
|
|
dateptr = buf;
|
|
|
|
while (buf < tail && *buf++ != '\n')
|
|
|
|
/* nada */;
|
|
|
|
if (buf >= tail)
|
|
|
|
return 0;
|
|
|
|
/* dateptr < buf && buf[-1] == '\n', so strtoul will stop at buf-1 */
|
2009-07-03 04:34:54 +00:00
|
|
|
return strtoul(dateptr, NULL, 10);
|
2005-04-18 18:39:48 +00:00
|
|
|
}
|
|
|
|
|
2006-04-07 06:58:51 +00:00
|
|
|
static struct commit_graft **commit_graft;
|
2005-07-30 07:58:28 +00:00
|
|
|
static int commit_graft_alloc, commit_graft_nr;
|
|
|
|
|
|
|
|
static int commit_graft_pos(const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
int lo, hi;
|
|
|
|
lo = 0;
|
|
|
|
hi = commit_graft_nr;
|
|
|
|
while (lo < hi) {
|
|
|
|
int mi = (lo + hi) / 2;
|
|
|
|
struct commit_graft *graft = commit_graft[mi];
|
2006-08-17 18:54:57 +00:00
|
|
|
int cmp = hashcmp(sha1, graft->sha1);
|
2005-07-30 07:58:28 +00:00
|
|
|
if (!cmp)
|
|
|
|
return mi;
|
|
|
|
if (cmp < 0)
|
|
|
|
hi = mi;
|
|
|
|
else
|
|
|
|
lo = mi + 1;
|
|
|
|
}
|
|
|
|
return -lo - 1;
|
|
|
|
}
|
|
|
|
|
2006-04-07 06:58:51 +00:00
|
|
|
int register_commit_graft(struct commit_graft *graft, int ignore_dups)
|
|
|
|
{
|
|
|
|
int pos = commit_graft_pos(graft->sha1);
|
2007-06-07 07:04:01 +00:00
|
|
|
|
2006-04-07 06:58:51 +00:00
|
|
|
if (0 <= pos) {
|
|
|
|
if (ignore_dups)
|
|
|
|
free(graft);
|
|
|
|
else {
|
|
|
|
free(commit_graft[pos]);
|
|
|
|
commit_graft[pos] = graft;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
pos = -pos - 1;
|
|
|
|
if (commit_graft_alloc <= ++commit_graft_nr) {
|
|
|
|
commit_graft_alloc = alloc_nr(commit_graft_alloc);
|
|
|
|
commit_graft = xrealloc(commit_graft,
|
|
|
|
sizeof(*commit_graft) *
|
|
|
|
commit_graft_alloc);
|
|
|
|
}
|
|
|
|
if (pos < commit_graft_nr)
|
|
|
|
memmove(commit_graft + pos + 1,
|
|
|
|
commit_graft + pos,
|
|
|
|
(commit_graft_nr - pos - 1) *
|
|
|
|
sizeof(*commit_graft));
|
|
|
|
commit_graft[pos] = graft;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct commit_graft *read_graft_line(char *buf, int len)
|
|
|
|
{
|
|
|
|
/* The format is just "Commit Parent1 Parent2 ...\n" */
|
|
|
|
int i;
|
|
|
|
struct commit_graft *graft = NULL;
|
|
|
|
|
2009-10-14 18:51:03 +00:00
|
|
|
while (len && isspace(buf[len-1]))
|
|
|
|
buf[--len] = '\0';
|
2006-04-17 11:41:49 +00:00
|
|
|
if (buf[0] == '#' || buf[0] == '\0')
|
2006-04-16 21:24:56 +00:00
|
|
|
return NULL;
|
2010-12-01 19:15:59 +00:00
|
|
|
if ((len + 1) % 41)
|
|
|
|
goto bad_graft_data;
|
2006-04-07 06:58:51 +00:00
|
|
|
i = (len + 1) / 41 - 1;
|
|
|
|
graft = xmalloc(sizeof(*graft) + 20 * i);
|
|
|
|
graft->nr_parent = i;
|
|
|
|
if (get_sha1_hex(buf, graft->sha1))
|
|
|
|
goto bad_graft_data;
|
|
|
|
for (i = 40; i < len; i += 41) {
|
|
|
|
if (buf[i] != ' ')
|
|
|
|
goto bad_graft_data;
|
|
|
|
if (get_sha1_hex(buf + i + 1, graft->parent[i/41]))
|
|
|
|
goto bad_graft_data;
|
|
|
|
}
|
|
|
|
return graft;
|
2010-12-01 19:15:59 +00:00
|
|
|
|
|
|
|
bad_graft_data:
|
|
|
|
error("bad graft data: %s", buf);
|
|
|
|
free(graft);
|
|
|
|
return NULL;
|
2006-04-07 06:58:51 +00:00
|
|
|
}
|
|
|
|
|
2008-10-02 10:14:30 +00:00
|
|
|
static int read_graft_file(const char *graft_file)
|
2005-07-30 07:58:28 +00:00
|
|
|
{
|
|
|
|
FILE *fp = fopen(graft_file, "r");
|
|
|
|
char buf[1024];
|
2006-04-07 06:58:51 +00:00
|
|
|
if (!fp)
|
|
|
|
return -1;
|
2005-07-30 07:58:28 +00:00
|
|
|
while (fgets(buf, sizeof(buf), fp)) {
|
|
|
|
/* The format is just "Commit Parent1 Parent2 ...\n" */
|
|
|
|
int len = strlen(buf);
|
2006-04-07 06:58:51 +00:00
|
|
|
struct commit_graft *graft = read_graft_line(buf, len);
|
2006-04-16 21:24:56 +00:00
|
|
|
if (!graft)
|
|
|
|
continue;
|
2006-04-07 06:58:51 +00:00
|
|
|
if (register_commit_graft(graft, 1))
|
2005-07-30 07:58:28 +00:00
|
|
|
error("duplicate graft data: %s", buf);
|
|
|
|
}
|
|
|
|
fclose(fp);
|
2006-04-07 06:58:51 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void prepare_commit_graft(void)
|
|
|
|
{
|
|
|
|
static int commit_graft_prepared;
|
|
|
|
char *graft_file;
|
|
|
|
|
|
|
|
if (commit_graft_prepared)
|
|
|
|
return;
|
|
|
|
graft_file = get_graft_file();
|
|
|
|
read_graft_file(graft_file);
|
2006-10-30 19:09:06 +00:00
|
|
|
/* make sure shallows are read */
|
|
|
|
is_repository_shallow();
|
2006-04-07 06:58:51 +00:00
|
|
|
commit_graft_prepared = 1;
|
2005-07-30 07:58:28 +00:00
|
|
|
}
|
|
|
|
|
2008-02-25 21:46:07 +00:00
|
|
|
struct commit_graft *lookup_commit_graft(const unsigned char *sha1)
|
2005-07-30 07:58:28 +00:00
|
|
|
{
|
|
|
|
int pos;
|
2006-04-07 06:58:51 +00:00
|
|
|
prepare_commit_graft();
|
2005-07-30 07:58:28 +00:00
|
|
|
pos = commit_graft_pos(sha1);
|
|
|
|
if (pos < 0)
|
|
|
|
return NULL;
|
|
|
|
return commit_graft[pos];
|
|
|
|
}
|
|
|
|
|
2011-08-18 12:29:35 +00:00
|
|
|
int for_each_commit_graft(each_commit_graft_fn fn, void *cb_data)
|
2006-10-30 19:09:06 +00:00
|
|
|
{
|
2011-08-18 12:29:35 +00:00
|
|
|
int i, ret;
|
|
|
|
for (i = ret = 0; i < commit_graft_nr && !ret; i++)
|
|
|
|
ret = fn(commit_graft[i], cb_data);
|
|
|
|
return ret;
|
2006-10-30 19:09:06 +00:00
|
|
|
}
|
|
|
|
|
2006-10-30 19:09:53 +00:00
|
|
|
int unregister_shallow(const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
int pos = commit_graft_pos(sha1);
|
|
|
|
if (pos < 0)
|
|
|
|
return -1;
|
|
|
|
if (pos + 1 < commit_graft_nr)
|
2010-01-29 10:28:44 +00:00
|
|
|
memmove(commit_graft + pos, commit_graft + pos + 1,
|
2006-10-30 19:09:53 +00:00
|
|
|
sizeof(struct commit_graft *)
|
|
|
|
* (commit_graft_nr - pos - 1));
|
|
|
|
commit_graft_nr--;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-05 10:52:20 +00:00
|
|
|
int parse_commit_buffer(struct commit *item, const void *buffer, unsigned long size)
|
2005-04-18 18:39:48 +00:00
|
|
|
{
|
2011-02-05 10:52:20 +00:00
|
|
|
const char *tail = buffer;
|
|
|
|
const char *bufptr = buffer;
|
2005-04-18 18:39:48 +00:00
|
|
|
unsigned char parent[20];
|
2005-06-21 03:26:03 +00:00
|
|
|
struct commit_list **pptr;
|
2005-07-30 07:58:28 +00:00
|
|
|
struct commit_graft *graft;
|
2005-05-06 17:48:34 +00:00
|
|
|
|
2005-04-18 18:39:48 +00:00
|
|
|
if (item->object.parsed)
|
|
|
|
return 0;
|
|
|
|
item->object.parsed = 1;
|
2006-06-28 10:51:00 +00:00
|
|
|
tail += size;
|
2008-01-19 17:35:23 +00:00
|
|
|
if (tail <= bufptr + 46 || memcmp(bufptr, "tree ", 5) || bufptr[45] != '\n')
|
2005-07-27 22:12:48 +00:00
|
|
|
return error("bogus commit object %s", sha1_to_hex(item->object.sha1));
|
2008-01-19 17:35:23 +00:00
|
|
|
if (get_sha1_hex(bufptr + 5, parent) < 0)
|
2006-02-23 01:47:10 +00:00
|
|
|
return error("bad tree pointer in commit %s",
|
|
|
|
sha1_to_hex(item->object.sha1));
|
2005-04-18 18:39:48 +00:00
|
|
|
item->tree = lookup_tree(parent);
|
|
|
|
bufptr += 46; /* "tree " + "hex sha1" + "\n" */
|
2005-06-21 03:26:03 +00:00
|
|
|
pptr = &item->parents;
|
2005-07-30 07:58:28 +00:00
|
|
|
|
|
|
|
graft = lookup_commit_graft(item->object.sha1);
|
2006-06-28 10:51:00 +00:00
|
|
|
while (bufptr + 48 < tail && !memcmp(bufptr, "parent ", 7)) {
|
2005-07-27 22:12:48 +00:00
|
|
|
struct commit *new_parent;
|
|
|
|
|
2006-06-28 10:51:00 +00:00
|
|
|
if (tail <= bufptr + 48 ||
|
|
|
|
get_sha1_hex(bufptr + 7, parent) ||
|
|
|
|
bufptr[47] != '\n')
|
2005-07-27 22:12:48 +00:00
|
|
|
return error("bad parents in commit %s", sha1_to_hex(item->object.sha1));
|
2005-07-30 07:58:28 +00:00
|
|
|
bufptr += 48;
|
2009-07-23 15:33:49 +00:00
|
|
|
/*
|
|
|
|
* The clone is shallow if nr_parent < 0, and we must
|
|
|
|
* not traverse its real parents even when we unhide them.
|
|
|
|
*/
|
|
|
|
if (graft && (graft->nr_parent < 0 || grafts_replace_parents))
|
2005-07-30 07:58:28 +00:00
|
|
|
continue;
|
2005-07-27 22:12:48 +00:00
|
|
|
new_parent = lookup_commit(parent);
|
2008-06-07 20:38:37 +00:00
|
|
|
if (new_parent)
|
2005-06-21 03:26:03 +00:00
|
|
|
pptr = &commit_list_insert(new_parent, pptr)->next;
|
2005-07-30 07:58:28 +00:00
|
|
|
}
|
|
|
|
if (graft) {
|
|
|
|
int i;
|
|
|
|
struct commit *new_parent;
|
|
|
|
for (i = 0; i < graft->nr_parent; i++) {
|
|
|
|
new_parent = lookup_commit(graft->parent[i]);
|
|
|
|
if (!new_parent)
|
|
|
|
continue;
|
|
|
|
pptr = &commit_list_insert(new_parent, pptr)->next;
|
|
|
|
}
|
2005-04-18 18:39:48 +00:00
|
|
|
}
|
2008-01-19 17:35:23 +00:00
|
|
|
item->date = parse_commit_date(bufptr, tail);
|
2005-11-17 05:32:44 +00:00
|
|
|
|
2005-04-18 18:39:48 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-05-06 17:48:34 +00:00
|
|
|
int parse_commit(struct commit *item)
|
|
|
|
{
|
2007-02-26 19:55:59 +00:00
|
|
|
enum object_type type;
|
2005-05-06 17:48:34 +00:00
|
|
|
void *buffer;
|
|
|
|
unsigned long size;
|
|
|
|
int ret;
|
|
|
|
|
2008-02-18 20:48:02 +00:00
|
|
|
if (!item)
|
|
|
|
return -1;
|
2005-05-06 17:48:34 +00:00
|
|
|
if (item->object.parsed)
|
|
|
|
return 0;
|
2007-02-26 19:55:59 +00:00
|
|
|
buffer = read_sha1_file(item->object.sha1, &type, &size);
|
2005-05-06 17:48:34 +00:00
|
|
|
if (!buffer)
|
|
|
|
return error("Could not read %s",
|
|
|
|
sha1_to_hex(item->object.sha1));
|
2007-02-26 19:55:59 +00:00
|
|
|
if (type != OBJ_COMMIT) {
|
2005-05-06 17:48:34 +00:00
|
|
|
free(buffer);
|
|
|
|
return error("Object %s not a commit",
|
|
|
|
sha1_to_hex(item->object.sha1));
|
|
|
|
}
|
|
|
|
ret = parse_commit_buffer(item, buffer, size);
|
[PATCH] Avoid wasting memory in git-rev-list
As pointed out on the list, git-rev-list can use a lot of memory.
One low-hanging fruit is to free the commit buffer for commits that we
parse. By default, parse_commit() will save away the buffer, since a lot
of cases do want it, and re-reading it continually would be unnecessary.
However, in many cases the buffer isn't actually necessary and saving it
just wastes memory.
We could just free the buffer ourselves, but especially in git-rev-list,
we actually end up using the helper functions that automatically add
parent commits to the commit lists, so we don't actually control the
commit parsing directly.
Instead, just make this behaviour of "parse_commit()" a global flag.
Maybe this is a bit tasteless, but it's very simple, and it makes a
noticable difference in memory usage.
Before the change:
[torvalds@g5 linux]$ /usr/bin/time git-rev-list v2.6.12..HEAD > /dev/null
0.26user 0.02system 0:00.28elapsed 99%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+3714minor)pagefaults 0swaps
after the change:
[torvalds@g5 linux]$ /usr/bin/time git-rev-list v2.6.12..HEAD > /dev/null
0.26user 0.00system 0:00.27elapsed 100%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+2433minor)pagefaults 0swaps
note how the minor faults have decreased from 3714 pages to 2433 pages.
That's all due to the fewer anonymous pages allocated to hold the comment
buffers and their metadata.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2005-09-15 21:43:17 +00:00
|
|
|
if (save_commit_buffer && !ret) {
|
2005-05-26 01:27:14 +00:00
|
|
|
item->buffer = buffer;
|
|
|
|
return 0;
|
|
|
|
}
|
2005-05-06 17:48:34 +00:00
|
|
|
free(buffer);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-07-22 13:18:30 +00:00
|
|
|
int find_commit_subject(const char *commit_buffer, const char **subject)
|
|
|
|
{
|
|
|
|
const char *eol;
|
|
|
|
const char *p = commit_buffer;
|
|
|
|
|
|
|
|
while (*p && (*p != '\n' || p[1] != '\n'))
|
|
|
|
p++;
|
|
|
|
if (*p) {
|
|
|
|
p += 2;
|
|
|
|
for (eol = p; *eol && *eol != '\n'; eol++)
|
|
|
|
; /* do nothing */
|
|
|
|
} else
|
|
|
|
eol = p;
|
|
|
|
|
|
|
|
*subject = p;
|
|
|
|
|
|
|
|
return eol - p;
|
|
|
|
}
|
|
|
|
|
2005-05-31 01:44:02 +00:00
|
|
|
struct commit_list *commit_list_insert(struct commit *item, struct commit_list **list_p)
|
2005-04-24 01:47:23 +00:00
|
|
|
{
|
2005-04-26 19:00:58 +00:00
|
|
|
struct commit_list *new_list = xmalloc(sizeof(struct commit_list));
|
2005-04-24 01:47:23 +00:00
|
|
|
new_list->item = item;
|
|
|
|
new_list->next = *list_p;
|
|
|
|
*list_p = new_list;
|
2005-05-31 01:44:02 +00:00
|
|
|
return new_list;
|
2005-04-24 01:47:23 +00:00
|
|
|
}
|
|
|
|
|
2008-06-27 16:21:55 +00:00
|
|
|
unsigned commit_list_count(const struct commit_list *l)
|
|
|
|
{
|
|
|
|
unsigned c = 0;
|
|
|
|
for (; l; l = l->next )
|
|
|
|
c++;
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2005-04-18 18:39:48 +00:00
|
|
|
void free_commit_list(struct commit_list *list)
|
|
|
|
{
|
|
|
|
while (list) {
|
|
|
|
struct commit_list *temp = list;
|
|
|
|
list = temp->next;
|
|
|
|
free(temp);
|
|
|
|
}
|
|
|
|
}
|
2005-04-24 01:47:23 +00:00
|
|
|
|
2010-11-27 01:58:14 +00:00
|
|
|
struct commit_list * commit_list_insert_by_date(struct commit *item, struct commit_list **list)
|
2005-04-24 01:47:23 +00:00
|
|
|
{
|
|
|
|
struct commit_list **pp = list;
|
|
|
|
struct commit_list *p;
|
|
|
|
while ((p = *pp) != NULL) {
|
|
|
|
if (p->item->date < item->date) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pp = &p->next;
|
|
|
|
}
|
2005-07-06 16:31:17 +00:00
|
|
|
return commit_list_insert(item, pp);
|
2005-04-24 01:47:23 +00:00
|
|
|
}
|
|
|
|
|
2007-06-07 07:04:01 +00:00
|
|
|
|
2010-11-27 01:58:14 +00:00
|
|
|
void commit_list_sort_by_date(struct commit_list **list)
|
2005-04-24 01:47:23 +00:00
|
|
|
{
|
|
|
|
struct commit_list *ret = NULL;
|
|
|
|
while (*list) {
|
2010-11-27 01:58:14 +00:00
|
|
|
commit_list_insert_by_date((*list)->item, &ret);
|
2005-04-24 01:47:23 +00:00
|
|
|
*list = (*list)->next;
|
|
|
|
}
|
|
|
|
*list = ret;
|
|
|
|
}
|
|
|
|
|
2005-04-24 03:29:22 +00:00
|
|
|
struct commit *pop_most_recent_commit(struct commit_list **list,
|
|
|
|
unsigned int mark)
|
2005-04-24 01:47:23 +00:00
|
|
|
{
|
|
|
|
struct commit *ret = (*list)->item;
|
|
|
|
struct commit_list *parents = ret->parents;
|
|
|
|
struct commit_list *old = *list;
|
|
|
|
|
|
|
|
*list = (*list)->next;
|
|
|
|
free(old);
|
|
|
|
|
|
|
|
while (parents) {
|
2005-04-24 02:21:28 +00:00
|
|
|
struct commit *commit = parents->item;
|
2008-02-18 20:48:03 +00:00
|
|
|
if (!parse_commit(commit) && !(commit->object.flags & mark)) {
|
2005-04-24 03:29:22 +00:00
|
|
|
commit->object.flags |= mark;
|
2010-11-27 01:58:14 +00:00
|
|
|
commit_list_insert_by_date(commit, list);
|
2005-04-24 02:21:28 +00:00
|
|
|
}
|
2005-04-24 01:47:23 +00:00
|
|
|
parents = parents->next;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
2005-06-01 15:34:23 +00:00
|
|
|
|
2006-01-08 02:52:42 +00:00
|
|
|
void clear_commit_marks(struct commit *commit, unsigned int mark)
|
|
|
|
{
|
2007-10-10 22:14:35 +00:00
|
|
|
while (commit) {
|
|
|
|
struct commit_list *parents;
|
2006-01-08 02:52:42 +00:00
|
|
|
|
2007-10-10 22:14:35 +00:00
|
|
|
if (!(mark & commit->object.flags))
|
|
|
|
return;
|
2006-07-05 00:45:22 +00:00
|
|
|
|
2007-10-10 22:14:35 +00:00
|
|
|
commit->object.flags &= ~mark;
|
|
|
|
|
|
|
|
parents = commit->parents;
|
|
|
|
if (!parents)
|
|
|
|
return;
|
|
|
|
|
|
|
|
while ((parents = parents->next))
|
|
|
|
clear_commit_marks(parents->item, mark);
|
|
|
|
|
|
|
|
commit = commit->parents->item;
|
2006-01-08 02:52:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-01 16:16:08 +00:00
|
|
|
void clear_commit_marks_for_object_array(struct object_array *a, unsigned mark)
|
|
|
|
{
|
|
|
|
struct object *object;
|
|
|
|
struct commit *commit;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < a->nr; i++) {
|
|
|
|
object = a->objects[i].item;
|
|
|
|
commit = lookup_commit_reference_gently(object->sha1, 1);
|
|
|
|
if (commit)
|
|
|
|
clear_commit_marks(commit, mark);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-06-06 15:39:40 +00:00
|
|
|
struct commit *pop_commit(struct commit_list **stack)
|
|
|
|
{
|
|
|
|
struct commit_list *top = *stack;
|
|
|
|
struct commit *item = top ? top->item : NULL;
|
|
|
|
|
|
|
|
if (top) {
|
|
|
|
*stack = top->next;
|
|
|
|
free(top);
|
|
|
|
}
|
|
|
|
return item;
|
|
|
|
}
|
|
|
|
|
2005-07-06 16:39:34 +00:00
|
|
|
/*
|
|
|
|
* Performs an in-place topological sort on the list supplied.
|
|
|
|
*/
|
2006-02-16 06:05:33 +00:00
|
|
|
void sort_in_topological_order(struct commit_list ** list, int lifo)
|
2006-03-10 09:21:37 +00:00
|
|
|
{
|
2007-11-02 20:32:58 +00:00
|
|
|
struct commit_list *next, *orig = *list;
|
|
|
|
struct commit_list *work, **insert;
|
|
|
|
struct commit_list **pptr;
|
2007-06-07 07:04:01 +00:00
|
|
|
|
2007-11-02 20:32:58 +00:00
|
|
|
if (!orig)
|
2005-12-24 12:12:43 +00:00
|
|
|
return;
|
2007-11-02 20:32:58 +00:00
|
|
|
*list = NULL;
|
|
|
|
|
|
|
|
/* Mark them and clear the indegree */
|
|
|
|
for (next = orig; next; next = next->next) {
|
|
|
|
struct commit *commit = next->item;
|
2008-07-23 00:51:36 +00:00
|
|
|
commit->indegree = 1;
|
2005-07-06 16:39:34 +00:00
|
|
|
}
|
2007-11-02 20:32:58 +00:00
|
|
|
|
2005-07-06 16:39:34 +00:00
|
|
|
/* update the indegree */
|
2007-11-02 20:32:58 +00:00
|
|
|
for (next = orig; next; next = next->next) {
|
2005-07-06 16:39:34 +00:00
|
|
|
struct commit_list * parents = next->item->parents;
|
|
|
|
while (parents) {
|
2007-11-02 20:32:58 +00:00
|
|
|
struct commit *parent = parents->item;
|
2006-03-10 09:21:37 +00:00
|
|
|
|
2008-07-23 00:51:36 +00:00
|
|
|
if (parent->indegree)
|
2007-11-02 20:32:58 +00:00
|
|
|
parent->indegree++;
|
|
|
|
parents = parents->next;
|
2005-07-06 16:39:34 +00:00
|
|
|
}
|
|
|
|
}
|
2007-11-02 20:32:58 +00:00
|
|
|
|
2007-06-07 07:04:01 +00:00
|
|
|
/*
|
2007-09-10 10:35:06 +00:00
|
|
|
* find the tips
|
|
|
|
*
|
|
|
|
* tips are nodes not reachable from any other node in the list
|
|
|
|
*
|
|
|
|
* the tips serve as a starting set for the work queue.
|
|
|
|
*/
|
2007-11-02 20:32:58 +00:00
|
|
|
work = NULL;
|
2005-11-14 18:01:26 +00:00
|
|
|
insert = &work;
|
2007-11-02 20:32:58 +00:00
|
|
|
for (next = orig; next; next = next->next) {
|
|
|
|
struct commit *commit = next->item;
|
2005-07-06 16:39:34 +00:00
|
|
|
|
2008-07-23 00:51:36 +00:00
|
|
|
if (commit->indegree == 1)
|
2007-11-02 20:32:58 +00:00
|
|
|
insert = &commit_list_insert(commit, insert)->next;
|
2005-07-06 16:39:34 +00:00
|
|
|
}
|
2006-02-16 06:05:33 +00:00
|
|
|
|
2005-07-06 16:39:34 +00:00
|
|
|
/* process the list in topological order */
|
2006-02-16 06:05:33 +00:00
|
|
|
if (!lifo)
|
2010-11-27 01:58:14 +00:00
|
|
|
commit_list_sort_by_date(&work);
|
2007-11-02 20:32:58 +00:00
|
|
|
|
|
|
|
pptr = list;
|
|
|
|
*list = NULL;
|
2005-07-06 16:39:34 +00:00
|
|
|
while (work) {
|
2007-11-02 20:32:58 +00:00
|
|
|
struct commit *commit;
|
|
|
|
struct commit_list *parents, *work_item;
|
2005-07-06 16:39:34 +00:00
|
|
|
|
2007-11-02 20:32:58 +00:00
|
|
|
work_item = work;
|
|
|
|
work = work_item->next;
|
|
|
|
work_item->next = NULL;
|
|
|
|
|
|
|
|
commit = work_item->item;
|
|
|
|
for (parents = commit->parents; parents ; parents = parents->next) {
|
2011-08-25 21:46:52 +00:00
|
|
|
struct commit *parent = parents->item;
|
2007-11-02 20:32:58 +00:00
|
|
|
|
2008-07-23 00:51:36 +00:00
|
|
|
if (!parent->indegree)
|
2007-11-02 20:32:58 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* parents are only enqueued for emission
|
|
|
|
* when all their children have been emitted thereby
|
|
|
|
* guaranteeing topological order.
|
|
|
|
*/
|
2008-07-23 00:51:36 +00:00
|
|
|
if (--parent->indegree == 1) {
|
2007-11-02 20:32:58 +00:00
|
|
|
if (!lifo)
|
2010-11-27 01:58:14 +00:00
|
|
|
commit_list_insert_by_date(parent, &work);
|
2007-11-02 20:32:58 +00:00
|
|
|
else
|
|
|
|
commit_list_insert(parent, &work);
|
2005-07-06 16:39:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
2007-09-10 10:35:06 +00:00
|
|
|
* work_item is a commit all of whose children
|
|
|
|
* have already been emitted. we can emit it now.
|
|
|
|
*/
|
2008-07-23 00:51:36 +00:00
|
|
|
commit->indegree = 0;
|
2007-11-02 20:32:58 +00:00
|
|
|
*pptr = work_item;
|
|
|
|
pptr = &work_item->next;
|
2005-07-06 16:39:34 +00:00
|
|
|
}
|
|
|
|
}
|
2006-06-29 13:17:32 +00:00
|
|
|
|
2007-01-09 07:10:49 +00:00
|
|
|
/* merge-base stuff */
|
2006-06-29 13:17:32 +00:00
|
|
|
|
2006-10-23 00:32:47 +00:00
|
|
|
/* bits #0..15 in revision.h */
|
|
|
|
#define PARENT1 (1u<<16)
|
|
|
|
#define PARENT2 (1u<<17)
|
|
|
|
#define STALE (1u<<18)
|
|
|
|
#define RESULT (1u<<19)
|
2006-06-29 13:17:32 +00:00
|
|
|
|
2007-01-09 07:10:49 +00:00
|
|
|
static const unsigned all_flags = (PARENT1 | PARENT2 | STALE | RESULT);
|
|
|
|
|
2006-06-29 13:17:32 +00:00
|
|
|
static struct commit *interesting(struct commit_list *list)
|
|
|
|
{
|
|
|
|
while (list) {
|
|
|
|
struct commit *commit = list->item;
|
|
|
|
list = list->next;
|
2006-07-02 18:34:17 +00:00
|
|
|
if (commit->object.flags & STALE)
|
2006-06-29 13:17:32 +00:00
|
|
|
continue;
|
|
|
|
return commit;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
Introduce get_merge_bases_many()
This introduces a new function get_merge_bases_many() which is a natural
extension of two commit merge base computation. It is given one commit
(one) and a set of other commits (twos), and computes the merge base of
one and a merge across other commits.
This is mostly useful to figure out the common ancestor when iterating
over heads during an octopus merge. When making an octopus between
commits A, B, C and D, we first merge tree of A and B, and then try to
merge C with it. If we were making pairwise merge, we would be recording
the tree resulting from the merge between A and B as a commit, say M, and
then the next round we will be computing the merge base between M and C.
o---C...*
/ .
o---B...M
/ .
o---o---A
But during an octopus merge, we actually do not create a commit M. In
order to figure out that the common ancestor to use for this merge,
instead of computing the merge base between C and M, we can call
merge_bases_many() with one set to C and twos containing A and B.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-27 16:22:02 +00:00
|
|
|
static struct commit_list *merge_bases_many(struct commit *one, int n, struct commit **twos)
|
2006-06-29 13:17:32 +00:00
|
|
|
{
|
|
|
|
struct commit_list *list = NULL;
|
|
|
|
struct commit_list *result = NULL;
|
Introduce get_merge_bases_many()
This introduces a new function get_merge_bases_many() which is a natural
extension of two commit merge base computation. It is given one commit
(one) and a set of other commits (twos), and computes the merge base of
one and a merge across other commits.
This is mostly useful to figure out the common ancestor when iterating
over heads during an octopus merge. When making an octopus between
commits A, B, C and D, we first merge tree of A and B, and then try to
merge C with it. If we were making pairwise merge, we would be recording
the tree resulting from the merge between A and B as a commit, say M, and
then the next round we will be computing the merge base between M and C.
o---C...*
/ .
o---B...M
/ .
o---o---A
But during an octopus merge, we actually do not create a commit M. In
order to figure out that the common ancestor to use for this merge,
instead of computing the merge base between C and M, we can call
merge_bases_many() with one set to C and twos containing A and B.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-27 16:22:02 +00:00
|
|
|
int i;
|
2006-06-29 13:17:32 +00:00
|
|
|
|
Introduce get_merge_bases_many()
This introduces a new function get_merge_bases_many() which is a natural
extension of two commit merge base computation. It is given one commit
(one) and a set of other commits (twos), and computes the merge base of
one and a merge across other commits.
This is mostly useful to figure out the common ancestor when iterating
over heads during an octopus merge. When making an octopus between
commits A, B, C and D, we first merge tree of A and B, and then try to
merge C with it. If we were making pairwise merge, we would be recording
the tree resulting from the merge between A and B as a commit, say M, and
then the next round we will be computing the merge base between M and C.
o---C...*
/ .
o---B...M
/ .
o---o---A
But during an octopus merge, we actually do not create a commit M. In
order to figure out that the common ancestor to use for this merge,
instead of computing the merge base between C and M, we can call
merge_bases_many() with one set to C and twos containing A and B.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-27 16:22:02 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
if (one == twos[i])
|
|
|
|
/*
|
|
|
|
* We do not mark this even with RESULT so we do not
|
|
|
|
* have to clean it up.
|
|
|
|
*/
|
|
|
|
return commit_list_insert(one, &result);
|
|
|
|
}
|
2006-06-29 13:17:32 +00:00
|
|
|
|
2008-02-18 20:47:57 +00:00
|
|
|
if (parse_commit(one))
|
|
|
|
return NULL;
|
Introduce get_merge_bases_many()
This introduces a new function get_merge_bases_many() which is a natural
extension of two commit merge base computation. It is given one commit
(one) and a set of other commits (twos), and computes the merge base of
one and a merge across other commits.
This is mostly useful to figure out the common ancestor when iterating
over heads during an octopus merge. When making an octopus between
commits A, B, C and D, we first merge tree of A and B, and then try to
merge C with it. If we were making pairwise merge, we would be recording
the tree resulting from the merge between A and B as a commit, say M, and
then the next round we will be computing the merge base between M and C.
o---C...*
/ .
o---B...M
/ .
o---o---A
But during an octopus merge, we actually do not create a commit M. In
order to figure out that the common ancestor to use for this merge,
instead of computing the merge base between C and M, we can call
merge_bases_many() with one set to C and twos containing A and B.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-27 16:22:02 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
if (parse_commit(twos[i]))
|
|
|
|
return NULL;
|
|
|
|
}
|
2006-06-29 13:17:32 +00:00
|
|
|
|
2006-07-05 01:46:42 +00:00
|
|
|
one->object.flags |= PARENT1;
|
2010-11-27 01:58:14 +00:00
|
|
|
commit_list_insert_by_date(one, &list);
|
Introduce get_merge_bases_many()
This introduces a new function get_merge_bases_many() which is a natural
extension of two commit merge base computation. It is given one commit
(one) and a set of other commits (twos), and computes the merge base of
one and a merge across other commits.
This is mostly useful to figure out the common ancestor when iterating
over heads during an octopus merge. When making an octopus between
commits A, B, C and D, we first merge tree of A and B, and then try to
merge C with it. If we were making pairwise merge, we would be recording
the tree resulting from the merge between A and B as a commit, say M, and
then the next round we will be computing the merge base between M and C.
o---C...*
/ .
o---B...M
/ .
o---o---A
But during an octopus merge, we actually do not create a commit M. In
order to figure out that the common ancestor to use for this merge,
instead of computing the merge base between C and M, we can call
merge_bases_many() with one set to C and twos containing A and B.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-27 16:22:02 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
twos[i]->object.flags |= PARENT2;
|
2010-11-27 01:58:14 +00:00
|
|
|
commit_list_insert_by_date(twos[i], &list);
|
Introduce get_merge_bases_many()
This introduces a new function get_merge_bases_many() which is a natural
extension of two commit merge base computation. It is given one commit
(one) and a set of other commits (twos), and computes the merge base of
one and a merge across other commits.
This is mostly useful to figure out the common ancestor when iterating
over heads during an octopus merge. When making an octopus between
commits A, B, C and D, we first merge tree of A and B, and then try to
merge C with it. If we were making pairwise merge, we would be recording
the tree resulting from the merge between A and B as a commit, say M, and
then the next round we will be computing the merge base between M and C.
o---C...*
/ .
o---B...M
/ .
o---o---A
But during an octopus merge, we actually do not create a commit M. In
order to figure out that the common ancestor to use for this merge,
instead of computing the merge base between C and M, we can call
merge_bases_many() with one set to C and twos containing A and B.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-27 16:22:02 +00:00
|
|
|
}
|
2006-06-29 13:17:32 +00:00
|
|
|
|
|
|
|
while (interesting(list)) {
|
2006-07-05 01:46:42 +00:00
|
|
|
struct commit *commit;
|
2006-06-29 13:17:32 +00:00
|
|
|
struct commit_list *parents;
|
2009-08-27 16:16:34 +00:00
|
|
|
struct commit_list *next;
|
2006-07-05 01:46:42 +00:00
|
|
|
int flags;
|
2006-06-29 13:17:32 +00:00
|
|
|
|
2006-07-05 01:46:42 +00:00
|
|
|
commit = list->item;
|
2009-08-27 16:16:34 +00:00
|
|
|
next = list->next;
|
2006-07-05 01:46:42 +00:00
|
|
|
free(list);
|
2009-08-27 16:16:34 +00:00
|
|
|
list = next;
|
2006-06-29 13:17:32 +00:00
|
|
|
|
2006-07-05 01:46:42 +00:00
|
|
|
flags = commit->object.flags & (PARENT1 | PARENT2 | STALE);
|
|
|
|
if (flags == (PARENT1 | PARENT2)) {
|
|
|
|
if (!(commit->object.flags & RESULT)) {
|
|
|
|
commit->object.flags |= RESULT;
|
2010-11-27 01:58:14 +00:00
|
|
|
commit_list_insert_by_date(commit, &result);
|
2006-07-05 01:46:42 +00:00
|
|
|
}
|
2006-07-02 18:34:17 +00:00
|
|
|
/* Mark parents of a found merge stale */
|
|
|
|
flags |= STALE;
|
2006-06-29 13:17:32 +00:00
|
|
|
}
|
|
|
|
parents = commit->parents;
|
|
|
|
while (parents) {
|
|
|
|
struct commit *p = parents->item;
|
|
|
|
parents = parents->next;
|
|
|
|
if ((p->object.flags & flags) == flags)
|
|
|
|
continue;
|
2008-02-18 20:47:57 +00:00
|
|
|
if (parse_commit(p))
|
|
|
|
return NULL;
|
2006-06-29 13:17:32 +00:00
|
|
|
p->object.flags |= flags;
|
2010-11-27 01:58:14 +00:00
|
|
|
commit_list_insert_by_date(p, &list);
|
2006-06-29 13:17:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-05 01:46:42 +00:00
|
|
|
/* Clean up the result to remove stale ones */
|
2007-01-09 07:10:49 +00:00
|
|
|
free_commit_list(list);
|
2006-07-05 01:46:42 +00:00
|
|
|
list = result; result = NULL;
|
|
|
|
while (list) {
|
2009-08-27 16:16:34 +00:00
|
|
|
struct commit_list *next = list->next;
|
2006-07-05 01:46:42 +00:00
|
|
|
if (!(list->item->object.flags & STALE))
|
2010-11-27 01:58:14 +00:00
|
|
|
commit_list_insert_by_date(list->item, &result);
|
2006-07-05 01:46:42 +00:00
|
|
|
free(list);
|
2009-08-27 16:16:34 +00:00
|
|
|
list = next;
|
2006-07-05 01:46:42 +00:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
2006-06-29 13:17:32 +00:00
|
|
|
|
2008-06-27 16:22:00 +00:00
|
|
|
struct commit_list *get_octopus_merge_bases(struct commit_list *in)
|
|
|
|
{
|
|
|
|
struct commit_list *i, *j, *k, *ret = NULL;
|
|
|
|
struct commit_list **pptr = &ret;
|
|
|
|
|
|
|
|
for (i = in; i; i = i->next) {
|
|
|
|
if (!ret)
|
|
|
|
pptr = &commit_list_insert(i->item, pptr)->next;
|
|
|
|
else {
|
|
|
|
struct commit_list *new = NULL, *end = NULL;
|
|
|
|
|
|
|
|
for (j = ret; j; j = j->next) {
|
|
|
|
struct commit_list *bases;
|
|
|
|
bases = get_merge_bases(i->item, j->item, 1);
|
|
|
|
if (!new)
|
|
|
|
new = bases;
|
|
|
|
else
|
|
|
|
end->next = bases;
|
|
|
|
for (k = bases; k; k = k->next)
|
|
|
|
end = k;
|
|
|
|
}
|
|
|
|
ret = new;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
Introduce get_merge_bases_many()
This introduces a new function get_merge_bases_many() which is a natural
extension of two commit merge base computation. It is given one commit
(one) and a set of other commits (twos), and computes the merge base of
one and a merge across other commits.
This is mostly useful to figure out the common ancestor when iterating
over heads during an octopus merge. When making an octopus between
commits A, B, C and D, we first merge tree of A and B, and then try to
merge C with it. If we were making pairwise merge, we would be recording
the tree resulting from the merge between A and B as a commit, say M, and
then the next round we will be computing the merge base between M and C.
o---C...*
/ .
o---B...M
/ .
o---o---A
But during an octopus merge, we actually do not create a commit M. In
order to figure out that the common ancestor to use for this merge,
instead of computing the merge base between C and M, we can call
merge_bases_many() with one set to C and twos containing A and B.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-27 16:22:02 +00:00
|
|
|
struct commit_list *get_merge_bases_many(struct commit *one,
|
|
|
|
int n,
|
|
|
|
struct commit **twos,
|
|
|
|
int cleanup)
|
2006-07-05 01:46:42 +00:00
|
|
|
{
|
|
|
|
struct commit_list *list;
|
|
|
|
struct commit **rslt;
|
|
|
|
struct commit_list *result;
|
|
|
|
int cnt, i, j;
|
|
|
|
|
Introduce get_merge_bases_many()
This introduces a new function get_merge_bases_many() which is a natural
extension of two commit merge base computation. It is given one commit
(one) and a set of other commits (twos), and computes the merge base of
one and a merge across other commits.
This is mostly useful to figure out the common ancestor when iterating
over heads during an octopus merge. When making an octopus between
commits A, B, C and D, we first merge tree of A and B, and then try to
merge C with it. If we were making pairwise merge, we would be recording
the tree resulting from the merge between A and B as a commit, say M, and
then the next round we will be computing the merge base between M and C.
o---C...*
/ .
o---B...M
/ .
o---o---A
But during an octopus merge, we actually do not create a commit M. In
order to figure out that the common ancestor to use for this merge,
instead of computing the merge base between C and M, we can call
merge_bases_many() with one set to C and twos containing A and B.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-27 16:22:02 +00:00
|
|
|
result = merge_bases_many(one, n, twos);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
if (one == twos[i])
|
|
|
|
return result;
|
|
|
|
}
|
2006-07-05 01:46:42 +00:00
|
|
|
if (!result || !result->next) {
|
|
|
|
if (cleanup) {
|
|
|
|
clear_commit_marks(one, all_flags);
|
Introduce get_merge_bases_many()
This introduces a new function get_merge_bases_many() which is a natural
extension of two commit merge base computation. It is given one commit
(one) and a set of other commits (twos), and computes the merge base of
one and a merge across other commits.
This is mostly useful to figure out the common ancestor when iterating
over heads during an octopus merge. When making an octopus between
commits A, B, C and D, we first merge tree of A and B, and then try to
merge C with it. If we were making pairwise merge, we would be recording
the tree resulting from the merge between A and B as a commit, say M, and
then the next round we will be computing the merge base between M and C.
o---C...*
/ .
o---B...M
/ .
o---o---A
But during an octopus merge, we actually do not create a commit M. In
order to figure out that the common ancestor to use for this merge,
instead of computing the merge base between C and M, we can call
merge_bases_many() with one set to C and twos containing A and B.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-27 16:22:02 +00:00
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
clear_commit_marks(twos[i], all_flags);
|
2006-06-29 13:17:32 +00:00
|
|
|
}
|
2006-07-05 01:46:42 +00:00
|
|
|
return result;
|
2006-06-29 13:17:32 +00:00
|
|
|
}
|
|
|
|
|
2006-07-05 01:46:42 +00:00
|
|
|
/* There are more than one */
|
|
|
|
cnt = 0;
|
|
|
|
list = result;
|
|
|
|
while (list) {
|
|
|
|
list = list->next;
|
|
|
|
cnt++;
|
|
|
|
}
|
|
|
|
rslt = xcalloc(cnt, sizeof(*rslt));
|
|
|
|
for (list = result, i = 0; list; list = list->next)
|
|
|
|
rslt[i++] = list->item;
|
|
|
|
free_commit_list(result);
|
|
|
|
|
|
|
|
clear_commit_marks(one, all_flags);
|
Introduce get_merge_bases_many()
This introduces a new function get_merge_bases_many() which is a natural
extension of two commit merge base computation. It is given one commit
(one) and a set of other commits (twos), and computes the merge base of
one and a merge across other commits.
This is mostly useful to figure out the common ancestor when iterating
over heads during an octopus merge. When making an octopus between
commits A, B, C and D, we first merge tree of A and B, and then try to
merge C with it. If we were making pairwise merge, we would be recording
the tree resulting from the merge between A and B as a commit, say M, and
then the next round we will be computing the merge base between M and C.
o---C...*
/ .
o---B...M
/ .
o---o---A
But during an octopus merge, we actually do not create a commit M. In
order to figure out that the common ancestor to use for this merge,
instead of computing the merge base between C and M, we can call
merge_bases_many() with one set to C and twos containing A and B.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-27 16:22:02 +00:00
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
clear_commit_marks(twos[i], all_flags);
|
2006-07-05 01:46:42 +00:00
|
|
|
for (i = 0; i < cnt - 1; i++) {
|
|
|
|
for (j = i+1; j < cnt; j++) {
|
|
|
|
if (!rslt[i] || !rslt[j])
|
|
|
|
continue;
|
Introduce get_merge_bases_many()
This introduces a new function get_merge_bases_many() which is a natural
extension of two commit merge base computation. It is given one commit
(one) and a set of other commits (twos), and computes the merge base of
one and a merge across other commits.
This is mostly useful to figure out the common ancestor when iterating
over heads during an octopus merge. When making an octopus between
commits A, B, C and D, we first merge tree of A and B, and then try to
merge C with it. If we were making pairwise merge, we would be recording
the tree resulting from the merge between A and B as a commit, say M, and
then the next round we will be computing the merge base between M and C.
o---C...*
/ .
o---B...M
/ .
o---o---A
But during an octopus merge, we actually do not create a commit M. In
order to figure out that the common ancestor to use for this merge,
instead of computing the merge base between C and M, we can call
merge_bases_many() with one set to C and twos containing A and B.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-27 16:22:02 +00:00
|
|
|
result = merge_bases_many(rslt[i], 1, &rslt[j]);
|
2006-07-05 01:46:42 +00:00
|
|
|
clear_commit_marks(rslt[i], all_flags);
|
|
|
|
clear_commit_marks(rslt[j], all_flags);
|
|
|
|
for (list = result; list; list = list->next) {
|
|
|
|
if (rslt[i] == list->item)
|
|
|
|
rslt[i] = NULL;
|
|
|
|
if (rslt[j] == list->item)
|
|
|
|
rslt[j] = NULL;
|
|
|
|
}
|
|
|
|
}
|
2006-07-05 00:45:22 +00:00
|
|
|
}
|
2006-06-29 13:17:32 +00:00
|
|
|
|
2006-07-05 01:46:42 +00:00
|
|
|
/* Surviving ones in rslt[] are the independent results */
|
|
|
|
result = NULL;
|
|
|
|
for (i = 0; i < cnt; i++) {
|
|
|
|
if (rslt[i])
|
2010-11-27 01:58:14 +00:00
|
|
|
commit_list_insert_by_date(rslt[i], &result);
|
2006-07-05 01:46:42 +00:00
|
|
|
}
|
|
|
|
free(rslt);
|
2006-06-29 13:17:32 +00:00
|
|
|
return result;
|
|
|
|
}
|
2006-12-19 08:14:04 +00:00
|
|
|
|
Introduce get_merge_bases_many()
This introduces a new function get_merge_bases_many() which is a natural
extension of two commit merge base computation. It is given one commit
(one) and a set of other commits (twos), and computes the merge base of
one and a merge across other commits.
This is mostly useful to figure out the common ancestor when iterating
over heads during an octopus merge. When making an octopus between
commits A, B, C and D, we first merge tree of A and B, and then try to
merge C with it. If we were making pairwise merge, we would be recording
the tree resulting from the merge between A and B as a commit, say M, and
then the next round we will be computing the merge base between M and C.
o---C...*
/ .
o---B...M
/ .
o---o---A
But during an octopus merge, we actually do not create a commit M. In
order to figure out that the common ancestor to use for this merge,
instead of computing the merge base between C and M, we can call
merge_bases_many() with one set to C and twos containing A and B.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-06-27 16:22:02 +00:00
|
|
|
struct commit_list *get_merge_bases(struct commit *one, struct commit *two,
|
|
|
|
int cleanup)
|
|
|
|
{
|
|
|
|
return get_merge_bases_many(one, 1, &two, cleanup);
|
|
|
|
}
|
|
|
|
|
2009-01-26 14:13:24 +00:00
|
|
|
int is_descendant_of(struct commit *commit, struct commit_list *with_commit)
|
|
|
|
{
|
|
|
|
if (!with_commit)
|
|
|
|
return 1;
|
|
|
|
while (with_commit) {
|
|
|
|
struct commit *other;
|
|
|
|
|
|
|
|
other = with_commit->item;
|
|
|
|
with_commit = with_commit->next;
|
|
|
|
if (in_merge_bases(other, &commit, 1))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-01-09 07:22:31 +00:00
|
|
|
int in_merge_bases(struct commit *commit, struct commit **reference, int num)
|
2006-12-19 08:14:04 +00:00
|
|
|
{
|
|
|
|
struct commit_list *bases, *b;
|
|
|
|
int ret = 0;
|
|
|
|
|
2007-01-09 07:22:31 +00:00
|
|
|
if (num == 1)
|
|
|
|
bases = get_merge_bases(commit, *reference, 1);
|
|
|
|
else
|
|
|
|
die("not yet");
|
2006-12-19 08:14:04 +00:00
|
|
|
for (b = bases; b; b = b->next) {
|
2007-01-09 07:22:31 +00:00
|
|
|
if (!hashcmp(commit->object.sha1, b->item->object.sha1)) {
|
2006-12-19 08:14:04 +00:00
|
|
|
ret = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
free_commit_list(bases);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-06-27 16:22:03 +00:00
|
|
|
|
|
|
|
struct commit_list *reduce_heads(struct commit_list *heads)
|
|
|
|
{
|
|
|
|
struct commit_list *p;
|
|
|
|
struct commit_list *result = NULL, **tail = &result;
|
|
|
|
struct commit **other;
|
|
|
|
size_t num_head, num_other;
|
|
|
|
|
|
|
|
if (!heads)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* Avoid unnecessary reallocations */
|
|
|
|
for (p = heads, num_head = 0; p; p = p->next)
|
|
|
|
num_head++;
|
|
|
|
other = xcalloc(sizeof(*other), num_head);
|
|
|
|
|
|
|
|
/* For each commit, see if it can be reached by others */
|
|
|
|
for (p = heads; p; p = p->next) {
|
|
|
|
struct commit_list *q, *base;
|
|
|
|
|
2008-07-14 07:09:41 +00:00
|
|
|
/* Do we already have this in the result? */
|
|
|
|
for (q = result; q; q = q->next)
|
|
|
|
if (p->item == q->item)
|
|
|
|
break;
|
|
|
|
if (q)
|
|
|
|
continue;
|
|
|
|
|
2008-06-27 16:22:03 +00:00
|
|
|
num_other = 0;
|
|
|
|
for (q = heads; q; q = q->next) {
|
2008-07-13 08:13:55 +00:00
|
|
|
if (p->item == q->item)
|
2008-06-27 16:22:03 +00:00
|
|
|
continue;
|
|
|
|
other[num_other++] = q->item;
|
|
|
|
}
|
2008-07-14 07:09:41 +00:00
|
|
|
if (num_other)
|
2008-06-27 16:22:03 +00:00
|
|
|
base = get_merge_bases_many(p->item, num_other, other, 1);
|
2008-07-14 07:09:41 +00:00
|
|
|
else
|
2008-06-27 16:22:03 +00:00
|
|
|
base = NULL;
|
|
|
|
/*
|
|
|
|
* If p->item does not have anything common with other
|
|
|
|
* commits, there won't be any merge base. If it is
|
|
|
|
* reachable from some of the others, p->item will be
|
|
|
|
* the merge base. If its history is connected with
|
|
|
|
* others, but p->item is not reachable by others, we
|
|
|
|
* will get something other than p->item back.
|
|
|
|
*/
|
|
|
|
if (!base || (base->item != p->item))
|
|
|
|
tail = &(commit_list_insert(p->item, tail)->next);
|
|
|
|
free_commit_list(base);
|
|
|
|
}
|
|
|
|
free(other);
|
|
|
|
return result;
|
|
|
|
}
|
make commit_tree a library function
Until now, this has been part of the commit-tree builtin.
However, it is already used by other builtins (like commit,
merge, and notes), and it would be useful to access it from
library code.
The check_valid helper has to come along, too, but is given
a more library-ish name of "assert_sha1_type".
Otherwise, the code is unchanged. There are still a few
rough edges for a library function, like printing the utf8
warning to stderr, but we can address those if and when they
come up as inappropriate.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-04-02 00:05:23 +00:00
|
|
|
|
2011-11-08 00:21:32 +00:00
|
|
|
static void handle_signed_tag(struct commit *parent, struct commit_extra_header ***tail)
|
|
|
|
{
|
|
|
|
struct merge_remote_desc *desc;
|
|
|
|
struct commit_extra_header *mergetag;
|
|
|
|
char *buf;
|
|
|
|
unsigned long size, len;
|
|
|
|
enum object_type type;
|
|
|
|
|
|
|
|
desc = merge_remote_util(parent);
|
|
|
|
if (!desc || !desc->obj)
|
|
|
|
return;
|
|
|
|
buf = read_sha1_file(desc->obj->sha1, &type, &size);
|
|
|
|
if (!buf || type != OBJ_TAG)
|
|
|
|
goto free_return;
|
|
|
|
len = parse_signature(buf, size);
|
|
|
|
if (size == len)
|
|
|
|
goto free_return;
|
|
|
|
/*
|
|
|
|
* We could verify this signature and either omit the tag when
|
|
|
|
* it does not validate, but the integrator may not have the
|
|
|
|
* public key of the signer of the tag he is merging, while a
|
|
|
|
* later auditor may have it while auditing, so let's not run
|
|
|
|
* verify-signed-buffer here for now...
|
|
|
|
*
|
|
|
|
* if (verify_signed_buffer(buf, len, buf + len, size - len, ...))
|
|
|
|
* warn("warning: signed tag unverified.");
|
|
|
|
*/
|
|
|
|
mergetag = xcalloc(1, sizeof(*mergetag));
|
|
|
|
mergetag->key = xstrdup("mergetag");
|
|
|
|
mergetag->value = buf;
|
|
|
|
mergetag->len = size;
|
|
|
|
|
|
|
|
**tail = mergetag;
|
|
|
|
*tail = &mergetag->next;
|
|
|
|
return;
|
|
|
|
|
|
|
|
free_return:
|
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
void append_merge_tag_headers(struct commit_list *parents,
|
|
|
|
struct commit_extra_header ***tail)
|
|
|
|
{
|
|
|
|
while (parents) {
|
|
|
|
struct commit *parent = parents->item;
|
|
|
|
handle_signed_tag(parent, tail);
|
|
|
|
parents = parents->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_extra_header(struct strbuf *buffer,
|
|
|
|
struct commit_extra_header *extra)
|
|
|
|
{
|
|
|
|
strbuf_addstr(buffer, extra->key);
|
2011-11-08 23:38:07 +00:00
|
|
|
if (extra->len)
|
|
|
|
strbuf_add_lines(buffer, " ", extra->value, extra->len);
|
|
|
|
else
|
|
|
|
strbuf_addch(buffer, '\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
struct commit_extra_header *read_commit_extra_headers(struct commit *commit)
|
|
|
|
{
|
|
|
|
struct commit_extra_header *extra = NULL;
|
|
|
|
unsigned long size;
|
|
|
|
enum object_type type;
|
|
|
|
char *buffer = read_sha1_file(commit->object.sha1, &type, &size);
|
|
|
|
if (buffer && type == OBJ_COMMIT)
|
|
|
|
extra = read_commit_extra_header_lines(buffer, size);
|
|
|
|
free(buffer);
|
|
|
|
return extra;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int standard_header_field(const char *field, size_t len)
|
|
|
|
{
|
|
|
|
return ((len == 4 && !memcmp(field, "tree ", 5)) ||
|
|
|
|
(len == 6 && !memcmp(field, "parent ", 7)) ||
|
|
|
|
(len == 6 && !memcmp(field, "author ", 7)) ||
|
|
|
|
(len == 9 && !memcmp(field, "committer ", 10)) ||
|
|
|
|
(len == 8 && !memcmp(field, "encoding ", 9)));
|
|
|
|
}
|
|
|
|
|
|
|
|
struct commit_extra_header *read_commit_extra_header_lines(const char *buffer, size_t size)
|
|
|
|
{
|
|
|
|
struct commit_extra_header *extra = NULL, **tail = &extra, *it = NULL;
|
|
|
|
const char *line, *next, *eof, *eob;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
|
|
|
for (line = buffer, eob = line + size;
|
|
|
|
line < eob && *line != '\n';
|
|
|
|
line = next) {
|
|
|
|
next = memchr(line, '\n', eob - line);
|
|
|
|
next = next ? next + 1 : eob;
|
|
|
|
if (*line == ' ') {
|
|
|
|
/* continuation */
|
|
|
|
if (it)
|
|
|
|
strbuf_add(&buf, line + 1, next - (line + 1));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (it)
|
|
|
|
it->value = strbuf_detach(&buf, &it->len);
|
|
|
|
strbuf_reset(&buf);
|
|
|
|
it = NULL;
|
|
|
|
|
|
|
|
eof = strchr(line, ' ');
|
|
|
|
if (next <= eof)
|
|
|
|
eof = next;
|
|
|
|
|
|
|
|
if (standard_header_field(line, eof - line))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
it = xcalloc(1, sizeof(*it));
|
|
|
|
it->key = xmemdupz(line, eof-line);
|
|
|
|
*tail = it;
|
|
|
|
tail = &it->next;
|
|
|
|
if (eof + 1 < next)
|
|
|
|
strbuf_add(&buf, eof + 1, next - (eof + 1));
|
|
|
|
}
|
|
|
|
if (it)
|
|
|
|
it->value = strbuf_detach(&buf, &it->len);
|
|
|
|
return extra;
|
2011-11-08 00:21:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void free_commit_extra_headers(struct commit_extra_header *extra)
|
|
|
|
{
|
|
|
|
while (extra) {
|
|
|
|
struct commit_extra_header *next = extra->next;
|
|
|
|
free(extra->key);
|
|
|
|
free(extra->value);
|
|
|
|
free(extra);
|
|
|
|
extra = next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int commit_tree(const char *msg, unsigned char *tree,
|
|
|
|
struct commit_list *parents, unsigned char *ret,
|
|
|
|
const char *author)
|
|
|
|
{
|
|
|
|
struct commit_extra_header *extra = NULL, **tail = &extra;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
append_merge_tag_headers(parents, &tail);
|
|
|
|
result = commit_tree_extended(msg, tree, parents, ret, author, extra);
|
|
|
|
free_commit_extra_headers(extra);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
make commit_tree a library function
Until now, this has been part of the commit-tree builtin.
However, it is already used by other builtins (like commit,
merge, and notes), and it would be useful to access it from
library code.
The check_valid helper has to come along, too, but is given
a more library-ish name of "assert_sha1_type".
Otherwise, the code is unchanged. There are still a few
rough edges for a library function, like printing the utf8
warning to stderr, but we can address those if and when they
come up as inappropriate.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-04-02 00:05:23 +00:00
|
|
|
static const char commit_utf8_warn[] =
|
|
|
|
"Warning: commit message does not conform to UTF-8.\n"
|
|
|
|
"You may want to amend it after fixing the message, or set the config\n"
|
|
|
|
"variable i18n.commitencoding to the encoding your project uses.\n";
|
|
|
|
|
2011-11-08 00:21:32 +00:00
|
|
|
int commit_tree_extended(const char *msg, unsigned char *tree,
|
|
|
|
struct commit_list *parents, unsigned char *ret,
|
|
|
|
const char *author, struct commit_extra_header *extra)
|
make commit_tree a library function
Until now, this has been part of the commit-tree builtin.
However, it is already used by other builtins (like commit,
merge, and notes), and it would be useful to access it from
library code.
The check_valid helper has to come along, too, but is given
a more library-ish name of "assert_sha1_type".
Otherwise, the code is unchanged. There are still a few
rough edges for a library function, like printing the utf8
warning to stderr, but we can address those if and when they
come up as inappropriate.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-04-02 00:05:23 +00:00
|
|
|
{
|
|
|
|
int result;
|
|
|
|
int encoding_is_utf8;
|
|
|
|
struct strbuf buffer;
|
|
|
|
|
|
|
|
assert_sha1_type(tree, OBJ_TREE);
|
|
|
|
|
|
|
|
/* Not having i18n.commitencoding is the same as having utf-8 */
|
|
|
|
encoding_is_utf8 = is_encoding_utf8(git_commit_encoding);
|
|
|
|
|
|
|
|
strbuf_init(&buffer, 8192); /* should avoid reallocs for the headers */
|
|
|
|
strbuf_addf(&buffer, "tree %s\n", sha1_to_hex(tree));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NOTE! This ordering means that the same exact tree merged with a
|
|
|
|
* different order of parents will be a _different_ changeset even
|
|
|
|
* if everything else stays the same.
|
|
|
|
*/
|
|
|
|
while (parents) {
|
|
|
|
struct commit_list *next = parents->next;
|
2011-11-08 00:21:32 +00:00
|
|
|
struct commit *parent = parents->item;
|
|
|
|
|
make commit_tree a library function
Until now, this has been part of the commit-tree builtin.
However, it is already used by other builtins (like commit,
merge, and notes), and it would be useful to access it from
library code.
The check_valid helper has to come along, too, but is given
a more library-ish name of "assert_sha1_type".
Otherwise, the code is unchanged. There are still a few
rough edges for a library function, like printing the utf8
warning to stderr, but we can address those if and when they
come up as inappropriate.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-04-02 00:05:23 +00:00
|
|
|
strbuf_addf(&buffer, "parent %s\n",
|
2011-11-08 00:21:32 +00:00
|
|
|
sha1_to_hex(parent->object.sha1));
|
make commit_tree a library function
Until now, this has been part of the commit-tree builtin.
However, it is already used by other builtins (like commit,
merge, and notes), and it would be useful to access it from
library code.
The check_valid helper has to come along, too, but is given
a more library-ish name of "assert_sha1_type".
Otherwise, the code is unchanged. There are still a few
rough edges for a library function, like printing the utf8
warning to stderr, but we can address those if and when they
come up as inappropriate.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-04-02 00:05:23 +00:00
|
|
|
free(parents);
|
|
|
|
parents = next;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Person/date information */
|
|
|
|
if (!author)
|
|
|
|
author = git_author_info(IDENT_ERROR_ON_NO_NAME);
|
|
|
|
strbuf_addf(&buffer, "author %s\n", author);
|
|
|
|
strbuf_addf(&buffer, "committer %s\n", git_committer_info(IDENT_ERROR_ON_NO_NAME));
|
|
|
|
if (!encoding_is_utf8)
|
|
|
|
strbuf_addf(&buffer, "encoding %s\n", git_commit_encoding);
|
2011-11-08 00:21:32 +00:00
|
|
|
|
|
|
|
while (extra) {
|
|
|
|
add_extra_header(&buffer, extra);
|
|
|
|
extra = extra->next;
|
|
|
|
}
|
make commit_tree a library function
Until now, this has been part of the commit-tree builtin.
However, it is already used by other builtins (like commit,
merge, and notes), and it would be useful to access it from
library code.
The check_valid helper has to come along, too, but is given
a more library-ish name of "assert_sha1_type".
Otherwise, the code is unchanged. There are still a few
rough edges for a library function, like printing the utf8
warning to stderr, but we can address those if and when they
come up as inappropriate.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-04-02 00:05:23 +00:00
|
|
|
strbuf_addch(&buffer, '\n');
|
|
|
|
|
|
|
|
/* And add the comment */
|
|
|
|
strbuf_addstr(&buffer, msg);
|
|
|
|
|
|
|
|
/* And check the encoding */
|
|
|
|
if (encoding_is_utf8 && !is_utf8(buffer.buf))
|
|
|
|
fprintf(stderr, commit_utf8_warn);
|
|
|
|
|
|
|
|
result = write_sha1_file(buffer.buf, buffer.len, commit_type, ret);
|
|
|
|
strbuf_release(&buffer);
|
|
|
|
return result;
|
|
|
|
}
|
2011-11-07 21:26:22 +00:00
|
|
|
|
|
|
|
struct commit *get_merge_parent(const char *name)
|
|
|
|
{
|
|
|
|
struct object *obj;
|
|
|
|
struct commit *commit;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
if (get_sha1(name, sha1))
|
|
|
|
return NULL;
|
|
|
|
obj = parse_object(sha1);
|
|
|
|
commit = (struct commit *)peel_to_type(name, 0, obj, OBJ_COMMIT);
|
|
|
|
if (commit && !commit->util) {
|
|
|
|
struct merge_remote_desc *desc;
|
|
|
|
desc = xmalloc(sizeof(*desc));
|
|
|
|
desc->obj = obj;
|
|
|
|
desc->name = strdup(name);
|
|
|
|
commit->util = desc;
|
|
|
|
}
|
|
|
|
return commit;
|
|
|
|
}
|