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"
|
commit: teach --gpg-sign option
This uses the gpg-interface.[ch] to allow signing the commit, i.e.
$ git commit --gpg-sign -m foo
You need a passphrase to unlock the secret key for
user: "Junio C Hamano <gitster@pobox.com>"
4096-bit RSA key, ID 96AFE6CB, created 2011-10-03 (main key ID 713660A7)
[master 8457d13] foo
1 files changed, 1 insertions(+), 0 deletions(-)
The lines of GPG detached signature are placed in a new multi-line header
field, instead of tucking the signature block at the end of the commit log
message text (similar to how signed tag is done), for multiple reasons:
- The signature won't clutter output from "git log" and friends if it is
in the extra header. If we place it at the end of the log message, we
would need to teach "git log" and friends to strip the signature block
with an option.
- Teaching new versions of "git log" and "gitk" to optionally verify and
show signatures is cleaner if we structurally know where the signature
block is (instead of scanning in the commit log message).
- The signature needs to be stripped upon various commit rewriting
operations, e.g. rebase, filter-branch, etc. They all already ignore
unknown headers, but if we place signature in the log message, all of
these tools (and third-party tools) also need to learn how a signature
block would look like.
- When we added the optional encoding header, all the tools (both in tree
and third-party) that acts on the raw commit object should have been
fixed to ignore headers they do not understand, so it is not like that
new header would be more likely to break than extra text in the commit.
A commit made with the above sample sequence would look like this:
$ git cat-file commit HEAD
tree 3cd71d90e3db4136e5260ab54599791c4f883b9d
parent b87755351a47b09cb27d6913e6e0e17e6254a4d4
author Junio C Hamano <gitster@pobox.com> 1317862251 -0700
committer Junio C Hamano <gitster@pobox.com> 1317862251 -0700
gpgsig -----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.10 (GNU/Linux)
iQIcBAABAgAGBQJOjPtrAAoJELC16IaWr+bL4TMP/RSe2Y/jYnCkds9unO5JEnfG
...
=dt98
-----END PGP SIGNATURE-----
foo
but "git log" (unless you ask for it with --pretty=raw) output is not
cluttered with the signature information.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-06 00:23:20 +00:00
|
|
|
#include "gpg-interface.h"
|
2012-03-31 22:10:39 +00:00
|
|
|
#include "mergesort.h"
|
commit-slab: introduce a macro to define a slab for new type
Introduce a header file to define a macro that can define the struct
type, initializer, accessor and cleanup functions to manage a commit
slab. Update the "indegree" topological sort facility using it.
To associate 32 flag bits with each commit, you can write:
define_commit_slab(flag32, uint32);
to declare "struct flag32" type, define an instance of it with
struct flag32 flags;
and initialize it by calling
init_flag32(&flags);
After that, a call to flag32_at() function
uint32 *fp = flag32_at(&flags, commit);
will return a pointer pointing at a uint32 for that commit. Once
you are done with these flags, clean them up with
clear_flag32(&flags);
Callers that cannot hard-code how wide the data to be associated
with the commit be at compile time can use the "_with_stride"
variant to initialize the slab.
Suppose you want to give one bit per existing ref, and paint commits
down to find which refs are descendants of each commit. Saying
typedef uint32 bits320[5];
define_commit_slab(flagbits, bits320);
at compile time will still limit your code with hard-coded limit,
because you may find that you have more than 320 refs at runtime.
The code can declare a commit slab "struct flagbits" like this
instead:
define_commit_slab(flagbits, unsigned char);
struct flagbits flags;
and initialize it by:
nrefs = ... count number of refs ...
init_flagbits_with_stride(&flags, (nrefs + 7) / 8);
so that
unsigned char *fp = flagbits_at(&flags, commit);
will return a pointer pointing at an array of 40 "unsigned char"s
associated with the commit, once you figure out nrefs is 320 at
runtime.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-13 18:56:41 +00:00
|
|
|
#include "commit-slab.h"
|
2013-06-07 04:58:12 +00:00
|
|
|
#include "prio-queue.h"
|
2014-02-26 18:49:22 +00:00
|
|
|
#include "sha1-lookup.h"
|
2005-04-18 18:39:48 +00:00
|
|
|
|
2012-09-15 20:58:15 +00:00
|
|
|
static struct commit_extra_header *read_commit_extra_header_lines(const char *buf, size_t len, const char **);
|
|
|
|
|
[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";
|
2013-04-09 06:52:56 +00:00
|
|
|
static int commit_count;
|
2005-04-18 18:39:48 +00:00
|
|
|
|
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);
|
2013-04-09 06:52:56 +00:00
|
|
|
if (!obj) {
|
|
|
|
struct commit *c = alloc_commit_node();
|
|
|
|
c->index = commit_count++;
|
|
|
|
return create_object(sha1, OBJ_COMMIT, c);
|
|
|
|
}
|
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;
|
|
|
|
|
2012-07-02 19:04:52 +00:00
|
|
|
if (get_sha1_committish(name, sha1))
|
2010-11-02 19:59:07 +00:00
|
|
|
return NULL;
|
|
|
|
commit = lookup_commit_reference(sha1);
|
2013-10-24 08:53:19 +00:00
|
|
|
if (parse_commit(commit))
|
2010-11-02 19:59:07 +00:00
|
|
|
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;
|
|
|
|
|
2014-02-26 18:49:22 +00:00
|
|
|
static const unsigned char *commit_graft_sha1_access(size_t index, void *table)
|
|
|
|
{
|
|
|
|
struct commit_graft **commit_graft_table = table;
|
|
|
|
return commit_graft_table[index]->sha1;
|
|
|
|
}
|
|
|
|
|
2005-07-30 07:58:28 +00:00
|
|
|
static int commit_graft_pos(const unsigned char *sha1)
|
|
|
|
{
|
2014-02-26 18:49:22 +00:00
|
|
|
return sha1_pos(sha1, commit_graft, commit_graft_nr,
|
|
|
|
commit_graft_sha1_access);
|
2005-07-30 07:58:28 +00:00
|
|
|
}
|
|
|
|
|
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;
|
2014-03-03 22:31:52 +00:00
|
|
|
ALLOC_GROW(commit_graft, commit_graft_nr + 1, commit_graft_alloc);
|
|
|
|
commit_graft_nr++;
|
2006-04-07 06:58:51 +00:00
|
|
|
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");
|
2013-12-27 20:49:57 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2006-04-07 06:58:51 +00:00
|
|
|
if (!fp)
|
|
|
|
return -1;
|
2013-12-27 20:49:57 +00:00
|
|
|
while (!strbuf_getwholeline(&buf, fp, '\n')) {
|
2005-07-30 07:58:28 +00:00
|
|
|
/* The format is just "Commit Parent1 Parent2 ...\n" */
|
2013-12-27 20:49:57 +00:00
|
|
|
struct commit_graft *graft = read_graft_line(buf.buf, 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))
|
2013-12-27 20:49:57 +00:00
|
|
|
error("duplicate graft data: %s", buf.buf);
|
2005-07-30 07:58:28 +00:00
|
|
|
}
|
|
|
|
fclose(fp);
|
2013-12-27 20:49:57 +00:00
|
|
|
strbuf_release(&buf);
|
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;
|
|
|
|
}
|
|
|
|
|
2013-10-24 08:52:36 +00:00
|
|
|
void parse_commit_or_die(struct commit *item)
|
|
|
|
{
|
|
|
|
if (parse_commit(item))
|
|
|
|
die("unable to parse commit %s",
|
|
|
|
item ? sha1_to_hex(item->object.sha1) : "(null)");
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
log: use true parents for diff even when rewriting
When using pathspec filtering in combination with diff-based log
output, parent simplification happens before the diff is computed.
The diff is therefore against the *simplified* parents.
This works okay, arguably by accident, in the normal case:
simplification reduces to one parent as long as the commit is TREESAME
to it. So the simplified parent of any given commit must have the
same tree contents on the filtered paths as its true (unfiltered)
parent.
However, --full-diff breaks this guarantee, and indeed gives pretty
spectacular results when comparing the output of
git log --graph --stat ...
git log --graph --full-diff --stat ...
(--graph internally kicks in parent simplification, much like
--parents).
To fix it, store a copy of the parent list before simplification (in a
slab) whenever --full-diff is in effect. Then use the stored parents
instead of the simplified ones in the commit display code paths. The
latter do not actually check for --full-diff to avoid duplicated code;
they just grab the original parents if save_parents() has not been
called for this revision walk.
For ordinary commits it should be obvious that this is the right thing
to do.
Merge commits are a bit subtle. Observe that with default
simplification, merge simplification is an all-or-nothing decision:
either the merge is TREESAME to one parent and disappears, or it is
different from all parents and the parent list remains intact.
Redundant parents are not pruned, so the existing code also shows them
as a merge.
So if we do show a merge commit, the parent list just consists of the
rewrite result on each parent. Running, e.g., --cc on this in
--full-diff mode is not very useful: if any commits were skipped, some
hunks will disagree with all sides of the merge (with one side,
because commits were skipped; with the others, because they didn't
have those changes in the first place). This triggers --cc showing
these hunks spuriously.
Therefore I believe that even for merge commits it is better to show
the diffs wrt. the original parents.
Reported-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Helped-by: Junio C Hamano <gitster@pobox.com>
Helped-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Thomas Rast <trast@inf.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-31 20:13:20 +00:00
|
|
|
struct commit_list *copy_commit_list(struct commit_list *list)
|
|
|
|
{
|
|
|
|
struct commit_list *head = NULL;
|
|
|
|
struct commit_list **pp = &head;
|
|
|
|
while (list) {
|
|
|
|
struct commit_list *new;
|
|
|
|
new = xmalloc(sizeof(struct commit_list));
|
|
|
|
new->item = list->item;
|
|
|
|
new->next = NULL;
|
|
|
|
*pp = new;
|
|
|
|
pp = &new->next;
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
return head;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2012-03-31 22:10:39 +00:00
|
|
|
static int commit_list_compare_by_date(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
unsigned long a_date = ((const struct commit_list *)a)->item->date;
|
|
|
|
unsigned long b_date = ((const struct commit_list *)b)->item->date;
|
|
|
|
if (a_date < b_date)
|
|
|
|
return 1;
|
|
|
|
if (a_date > b_date)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *commit_list_get_next(const void *a)
|
|
|
|
{
|
|
|
|
return ((const struct commit_list *)a)->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void commit_list_set_next(void *a, void *next)
|
|
|
|
{
|
|
|
|
((struct commit_list *)a)->next = next;
|
|
|
|
}
|
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
|
|
|
{
|
2012-04-17 18:07:01 +00:00
|
|
|
*list = llist_mergesort(*list, commit_list_get_next, commit_list_set_next,
|
|
|
|
commit_list_compare_by_date);
|
2005-04-24 01:47:23 +00:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2012-01-14 12:19:53 +00:00
|
|
|
static void clear_commit_marks_1(struct commit_list **plist,
|
|
|
|
struct commit *commit, unsigned int mark)
|
2006-01-08 02:52:42 +00:00
|
|
|
{
|
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))
|
2012-01-14 12:19:53 +00:00
|
|
|
commit_list_insert(parents->item, plist);
|
2007-10-10 22:14:35 +00:00
|
|
|
|
|
|
|
commit = commit->parents->item;
|
2006-01-08 02:52:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-05 19:42:20 +00:00
|
|
|
void clear_commit_marks_many(int nr, struct commit **commit, unsigned int mark)
|
2012-01-14 12:19:53 +00:00
|
|
|
{
|
|
|
|
struct commit_list *list = NULL;
|
2013-03-05 19:42:20 +00:00
|
|
|
|
|
|
|
while (nr--) {
|
|
|
|
commit_list_insert(*commit, &list);
|
|
|
|
commit++;
|
|
|
|
}
|
2012-01-14 12:19:53 +00:00
|
|
|
while (list)
|
|
|
|
clear_commit_marks_1(&list, pop_commit(&list), mark);
|
|
|
|
}
|
|
|
|
|
2013-03-05 19:42:20 +00:00
|
|
|
void clear_commit_marks(struct commit *commit, unsigned int mark)
|
|
|
|
{
|
|
|
|
clear_commit_marks_many(1, &commit, mark);
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
commit-slab: introduce a macro to define a slab for new type
Introduce a header file to define a macro that can define the struct
type, initializer, accessor and cleanup functions to manage a commit
slab. Update the "indegree" topological sort facility using it.
To associate 32 flag bits with each commit, you can write:
define_commit_slab(flag32, uint32);
to declare "struct flag32" type, define an instance of it with
struct flag32 flags;
and initialize it by calling
init_flag32(&flags);
After that, a call to flag32_at() function
uint32 *fp = flag32_at(&flags, commit);
will return a pointer pointing at a uint32 for that commit. Once
you are done with these flags, clean them up with
clear_flag32(&flags);
Callers that cannot hard-code how wide the data to be associated
with the commit be at compile time can use the "_with_stride"
variant to initialize the slab.
Suppose you want to give one bit per existing ref, and paint commits
down to find which refs are descendants of each commit. Saying
typedef uint32 bits320[5];
define_commit_slab(flagbits, bits320);
at compile time will still limit your code with hard-coded limit,
because you may find that you have more than 320 refs at runtime.
The code can declare a commit slab "struct flagbits" like this
instead:
define_commit_slab(flagbits, unsigned char);
struct flagbits flags;
and initialize it by:
nrefs = ... count number of refs ...
init_flagbits_with_stride(&flags, (nrefs + 7) / 8);
so that
unsigned char *fp = flagbits_at(&flags, commit);
will return a pointer pointing at an array of 40 "unsigned char"s
associated with the commit, once you figure out nrefs is 320 at
runtime.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-13 18:56:41 +00:00
|
|
|
/*
|
|
|
|
* Topological sort support
|
|
|
|
*/
|
2013-04-09 06:52:56 +00:00
|
|
|
|
commit-slab: introduce a macro to define a slab for new type
Introduce a header file to define a macro that can define the struct
type, initializer, accessor and cleanup functions to manage a commit
slab. Update the "indegree" topological sort facility using it.
To associate 32 flag bits with each commit, you can write:
define_commit_slab(flag32, uint32);
to declare "struct flag32" type, define an instance of it with
struct flag32 flags;
and initialize it by calling
init_flag32(&flags);
After that, a call to flag32_at() function
uint32 *fp = flag32_at(&flags, commit);
will return a pointer pointing at a uint32 for that commit. Once
you are done with these flags, clean them up with
clear_flag32(&flags);
Callers that cannot hard-code how wide the data to be associated
with the commit be at compile time can use the "_with_stride"
variant to initialize the slab.
Suppose you want to give one bit per existing ref, and paint commits
down to find which refs are descendants of each commit. Saying
typedef uint32 bits320[5];
define_commit_slab(flagbits, bits320);
at compile time will still limit your code with hard-coded limit,
because you may find that you have more than 320 refs at runtime.
The code can declare a commit slab "struct flagbits" like this
instead:
define_commit_slab(flagbits, unsigned char);
struct flagbits flags;
and initialize it by:
nrefs = ... count number of refs ...
init_flagbits_with_stride(&flags, (nrefs + 7) / 8);
so that
unsigned char *fp = flagbits_at(&flags, commit);
will return a pointer pointing at an array of 40 "unsigned char"s
associated with the commit, once you figure out nrefs is 320 at
runtime.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-13 18:56:41 +00:00
|
|
|
/* count number of children that have not been emitted */
|
|
|
|
define_commit_slab(indegree_slab, int);
|
2013-04-09 06:52:56 +00:00
|
|
|
|
2013-06-07 17:35:54 +00:00
|
|
|
/* record author-date for each commit object */
|
|
|
|
define_commit_slab(author_date_slab, unsigned long);
|
|
|
|
|
|
|
|
static void record_author_date(struct author_date_slab *author_date,
|
|
|
|
struct commit *commit)
|
|
|
|
{
|
2014-03-04 21:06:30 +00:00
|
|
|
const char *buf, *line_end, *ident_line;
|
2013-06-07 17:35:54 +00:00
|
|
|
char *buffer = NULL;
|
|
|
|
struct ident_split ident;
|
|
|
|
char *date_end;
|
|
|
|
unsigned long date;
|
|
|
|
|
|
|
|
if (!commit->buffer) {
|
|
|
|
unsigned long size;
|
|
|
|
enum object_type type;
|
|
|
|
buffer = read_sha1_file(commit->object.sha1, &type, &size);
|
|
|
|
if (!buffer)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (buf = commit->buffer ? commit->buffer : buffer;
|
|
|
|
buf;
|
|
|
|
buf = line_end + 1) {
|
|
|
|
line_end = strchrnul(buf, '\n');
|
2014-03-04 21:06:30 +00:00
|
|
|
ident_line = skip_prefix(buf, "author ");
|
|
|
|
if (!ident_line) {
|
2013-06-07 17:35:54 +00:00
|
|
|
if (!line_end[0] || line_end[1] == '\n')
|
|
|
|
return; /* end of header */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (split_ident_line(&ident,
|
2014-03-04 21:06:30 +00:00
|
|
|
ident_line, line_end - ident_line) ||
|
2013-06-07 17:35:54 +00:00
|
|
|
!ident.date_begin || !ident.date_end)
|
|
|
|
goto fail_exit; /* malformed "author" line */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
date = strtoul(ident.date_begin, &date_end, 10);
|
|
|
|
if (date_end != ident.date_end)
|
|
|
|
goto fail_exit; /* malformed date */
|
|
|
|
*(author_date_slab_at(author_date, commit)) = date;
|
|
|
|
|
|
|
|
fail_exit:
|
|
|
|
free(buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int compare_commits_by_author_date(const void *a_, const void *b_,
|
|
|
|
void *cb_data)
|
|
|
|
{
|
|
|
|
const struct commit *a = a_, *b = b_;
|
|
|
|
struct author_date_slab *author_date = cb_data;
|
|
|
|
unsigned long a_date = *(author_date_slab_at(author_date, a));
|
|
|
|
unsigned long b_date = *(author_date_slab_at(author_date, b));
|
|
|
|
|
|
|
|
/* newer commits with larger date first */
|
|
|
|
if (a_date < b_date)
|
|
|
|
return 1;
|
|
|
|
else if (a_date > b_date)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-02 06:21:48 +00:00
|
|
|
int compare_commits_by_commit_date(const void *a_, const void *b_, void *unused)
|
2013-06-07 04:58:12 +00:00
|
|
|
{
|
|
|
|
const struct commit *a = a_, *b = b_;
|
|
|
|
/* newer commits with larger date first */
|
|
|
|
if (a->date < b->date)
|
|
|
|
return 1;
|
|
|
|
else if (a->date > b->date)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-07-06 16:39:34 +00:00
|
|
|
/*
|
|
|
|
* Performs an in-place topological sort on the list supplied.
|
|
|
|
*/
|
2013-06-07 04:58:12 +00:00
|
|
|
void sort_in_topological_order(struct commit_list **list, enum rev_sort_order sort_order)
|
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 **pptr;
|
commit-slab: introduce a macro to define a slab for new type
Introduce a header file to define a macro that can define the struct
type, initializer, accessor and cleanup functions to manage a commit
slab. Update the "indegree" topological sort facility using it.
To associate 32 flag bits with each commit, you can write:
define_commit_slab(flag32, uint32);
to declare "struct flag32" type, define an instance of it with
struct flag32 flags;
and initialize it by calling
init_flag32(&flags);
After that, a call to flag32_at() function
uint32 *fp = flag32_at(&flags, commit);
will return a pointer pointing at a uint32 for that commit. Once
you are done with these flags, clean them up with
clear_flag32(&flags);
Callers that cannot hard-code how wide the data to be associated
with the commit be at compile time can use the "_with_stride"
variant to initialize the slab.
Suppose you want to give one bit per existing ref, and paint commits
down to find which refs are descendants of each commit. Saying
typedef uint32 bits320[5];
define_commit_slab(flagbits, bits320);
at compile time will still limit your code with hard-coded limit,
because you may find that you have more than 320 refs at runtime.
The code can declare a commit slab "struct flagbits" like this
instead:
define_commit_slab(flagbits, unsigned char);
struct flagbits flags;
and initialize it by:
nrefs = ... count number of refs ...
init_flagbits_with_stride(&flags, (nrefs + 7) / 8);
so that
unsigned char *fp = flagbits_at(&flags, commit);
will return a pointer pointing at an array of 40 "unsigned char"s
associated with the commit, once you figure out nrefs is 320 at
runtime.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-13 18:56:41 +00:00
|
|
|
struct indegree_slab indegree;
|
2013-06-07 04:58:12 +00:00
|
|
|
struct prio_queue queue;
|
|
|
|
struct commit *commit;
|
2013-06-07 17:35:54 +00:00
|
|
|
struct author_date_slab author_date;
|
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;
|
|
|
|
|
commit-slab: introduce a macro to define a slab for new type
Introduce a header file to define a macro that can define the struct
type, initializer, accessor and cleanup functions to manage a commit
slab. Update the "indegree" topological sort facility using it.
To associate 32 flag bits with each commit, you can write:
define_commit_slab(flag32, uint32);
to declare "struct flag32" type, define an instance of it with
struct flag32 flags;
and initialize it by calling
init_flag32(&flags);
After that, a call to flag32_at() function
uint32 *fp = flag32_at(&flags, commit);
will return a pointer pointing at a uint32 for that commit. Once
you are done with these flags, clean them up with
clear_flag32(&flags);
Callers that cannot hard-code how wide the data to be associated
with the commit be at compile time can use the "_with_stride"
variant to initialize the slab.
Suppose you want to give one bit per existing ref, and paint commits
down to find which refs are descendants of each commit. Saying
typedef uint32 bits320[5];
define_commit_slab(flagbits, bits320);
at compile time will still limit your code with hard-coded limit,
because you may find that you have more than 320 refs at runtime.
The code can declare a commit slab "struct flagbits" like this
instead:
define_commit_slab(flagbits, unsigned char);
struct flagbits flags;
and initialize it by:
nrefs = ... count number of refs ...
init_flagbits_with_stride(&flags, (nrefs + 7) / 8);
so that
unsigned char *fp = flagbits_at(&flags, commit);
will return a pointer pointing at an array of 40 "unsigned char"s
associated with the commit, once you figure out nrefs is 320 at
runtime.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-13 18:56:41 +00:00
|
|
|
init_indegree_slab(&indegree);
|
2013-06-07 04:58:12 +00:00
|
|
|
memset(&queue, '\0', sizeof(queue));
|
2013-06-07 17:35:54 +00:00
|
|
|
|
2013-06-07 04:58:12 +00:00
|
|
|
switch (sort_order) {
|
|
|
|
default: /* REV_SORT_IN_GRAPH_ORDER */
|
|
|
|
queue.compare = NULL;
|
|
|
|
break;
|
|
|
|
case REV_SORT_BY_COMMIT_DATE:
|
|
|
|
queue.compare = compare_commits_by_commit_date;
|
|
|
|
break;
|
2013-06-07 17:35:54 +00:00
|
|
|
case REV_SORT_BY_AUTHOR_DATE:
|
|
|
|
init_author_date_slab(&author_date);
|
|
|
|
queue.compare = compare_commits_by_author_date;
|
|
|
|
queue.cb_data = &author_date;
|
|
|
|
break;
|
2013-06-07 04:58:12 +00:00
|
|
|
}
|
2013-04-09 06:52:56 +00:00
|
|
|
|
2007-11-02 20:32:58 +00:00
|
|
|
/* Mark them and clear the indegree */
|
|
|
|
for (next = orig; next; next = next->next) {
|
|
|
|
struct commit *commit = next->item;
|
commit-slab: introduce a macro to define a slab for new type
Introduce a header file to define a macro that can define the struct
type, initializer, accessor and cleanup functions to manage a commit
slab. Update the "indegree" topological sort facility using it.
To associate 32 flag bits with each commit, you can write:
define_commit_slab(flag32, uint32);
to declare "struct flag32" type, define an instance of it with
struct flag32 flags;
and initialize it by calling
init_flag32(&flags);
After that, a call to flag32_at() function
uint32 *fp = flag32_at(&flags, commit);
will return a pointer pointing at a uint32 for that commit. Once
you are done with these flags, clean them up with
clear_flag32(&flags);
Callers that cannot hard-code how wide the data to be associated
with the commit be at compile time can use the "_with_stride"
variant to initialize the slab.
Suppose you want to give one bit per existing ref, and paint commits
down to find which refs are descendants of each commit. Saying
typedef uint32 bits320[5];
define_commit_slab(flagbits, bits320);
at compile time will still limit your code with hard-coded limit,
because you may find that you have more than 320 refs at runtime.
The code can declare a commit slab "struct flagbits" like this
instead:
define_commit_slab(flagbits, unsigned char);
struct flagbits flags;
and initialize it by:
nrefs = ... count number of refs ...
init_flagbits_with_stride(&flags, (nrefs + 7) / 8);
so that
unsigned char *fp = flagbits_at(&flags, commit);
will return a pointer pointing at an array of 40 "unsigned char"s
associated with the commit, once you figure out nrefs is 320 at
runtime.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-13 18:56:41 +00:00
|
|
|
*(indegree_slab_at(&indegree, commit)) = 1;
|
2013-06-07 17:35:54 +00:00
|
|
|
/* also record the author dates, if needed */
|
|
|
|
if (sort_order == REV_SORT_BY_AUTHOR_DATE)
|
|
|
|
record_author_date(&author_date, commit);
|
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) {
|
2013-06-07 04:58:12 +00:00
|
|
|
struct commit_list *parents = next->item->parents;
|
2005-07-06 16:39:34 +00:00
|
|
|
while (parents) {
|
2007-11-02 20:32:58 +00:00
|
|
|
struct commit *parent = parents->item;
|
commit-slab: introduce a macro to define a slab for new type
Introduce a header file to define a macro that can define the struct
type, initializer, accessor and cleanup functions to manage a commit
slab. Update the "indegree" topological sort facility using it.
To associate 32 flag bits with each commit, you can write:
define_commit_slab(flag32, uint32);
to declare "struct flag32" type, define an instance of it with
struct flag32 flags;
and initialize it by calling
init_flag32(&flags);
After that, a call to flag32_at() function
uint32 *fp = flag32_at(&flags, commit);
will return a pointer pointing at a uint32 for that commit. Once
you are done with these flags, clean them up with
clear_flag32(&flags);
Callers that cannot hard-code how wide the data to be associated
with the commit be at compile time can use the "_with_stride"
variant to initialize the slab.
Suppose you want to give one bit per existing ref, and paint commits
down to find which refs are descendants of each commit. Saying
typedef uint32 bits320[5];
define_commit_slab(flagbits, bits320);
at compile time will still limit your code with hard-coded limit,
because you may find that you have more than 320 refs at runtime.
The code can declare a commit slab "struct flagbits" like this
instead:
define_commit_slab(flagbits, unsigned char);
struct flagbits flags;
and initialize it by:
nrefs = ... count number of refs ...
init_flagbits_with_stride(&flags, (nrefs + 7) / 8);
so that
unsigned char *fp = flagbits_at(&flags, commit);
will return a pointer pointing at an array of 40 "unsigned char"s
associated with the commit, once you figure out nrefs is 320 at
runtime.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-13 18:56:41 +00:00
|
|
|
int *pi = indegree_slab_at(&indegree, parent);
|
2006-03-10 09:21:37 +00:00
|
|
|
|
2013-04-09 06:52:56 +00:00
|
|
|
if (*pi)
|
|
|
|
(*pi)++;
|
2007-11-02 20:32:58 +00:00
|
|
|
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
|
|
|
for (next = orig; next; next = next->next) {
|
|
|
|
struct commit *commit = next->item;
|
2005-07-06 16:39:34 +00:00
|
|
|
|
commit-slab: introduce a macro to define a slab for new type
Introduce a header file to define a macro that can define the struct
type, initializer, accessor and cleanup functions to manage a commit
slab. Update the "indegree" topological sort facility using it.
To associate 32 flag bits with each commit, you can write:
define_commit_slab(flag32, uint32);
to declare "struct flag32" type, define an instance of it with
struct flag32 flags;
and initialize it by calling
init_flag32(&flags);
After that, a call to flag32_at() function
uint32 *fp = flag32_at(&flags, commit);
will return a pointer pointing at a uint32 for that commit. Once
you are done with these flags, clean them up with
clear_flag32(&flags);
Callers that cannot hard-code how wide the data to be associated
with the commit be at compile time can use the "_with_stride"
variant to initialize the slab.
Suppose you want to give one bit per existing ref, and paint commits
down to find which refs are descendants of each commit. Saying
typedef uint32 bits320[5];
define_commit_slab(flagbits, bits320);
at compile time will still limit your code with hard-coded limit,
because you may find that you have more than 320 refs at runtime.
The code can declare a commit slab "struct flagbits" like this
instead:
define_commit_slab(flagbits, unsigned char);
struct flagbits flags;
and initialize it by:
nrefs = ... count number of refs ...
init_flagbits_with_stride(&flags, (nrefs + 7) / 8);
so that
unsigned char *fp = flagbits_at(&flags, commit);
will return a pointer pointing at an array of 40 "unsigned char"s
associated with the commit, once you figure out nrefs is 320 at
runtime.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-13 18:56:41 +00:00
|
|
|
if (*(indegree_slab_at(&indegree, commit)) == 1)
|
2013-06-07 04:58:12 +00:00
|
|
|
prio_queue_put(&queue, commit);
|
2005-07-06 16:39:34 +00:00
|
|
|
}
|
2006-02-16 06:05:33 +00:00
|
|
|
|
2013-06-07 04:58:12 +00:00
|
|
|
/*
|
|
|
|
* This is unfortunate; the initial tips need to be shown
|
|
|
|
* in the order given from the revision traversal machinery.
|
|
|
|
*/
|
|
|
|
if (sort_order == REV_SORT_IN_GRAPH_ORDER)
|
|
|
|
prio_queue_reverse(&queue);
|
|
|
|
|
|
|
|
/* We no longer need the commit list */
|
|
|
|
free_commit_list(orig);
|
2007-11-02 20:32:58 +00:00
|
|
|
|
|
|
|
pptr = list;
|
|
|
|
*list = NULL;
|
2013-06-07 04:58:12 +00:00
|
|
|
while ((commit = prio_queue_get(&queue)) != NULL) {
|
|
|
|
struct commit_list *parents;
|
2007-11-02 20:32:58 +00:00
|
|
|
|
|
|
|
for (parents = commit->parents; parents ; parents = parents->next) {
|
2011-08-25 21:46:52 +00:00
|
|
|
struct commit *parent = parents->item;
|
commit-slab: introduce a macro to define a slab for new type
Introduce a header file to define a macro that can define the struct
type, initializer, accessor and cleanup functions to manage a commit
slab. Update the "indegree" topological sort facility using it.
To associate 32 flag bits with each commit, you can write:
define_commit_slab(flag32, uint32);
to declare "struct flag32" type, define an instance of it with
struct flag32 flags;
and initialize it by calling
init_flag32(&flags);
After that, a call to flag32_at() function
uint32 *fp = flag32_at(&flags, commit);
will return a pointer pointing at a uint32 for that commit. Once
you are done with these flags, clean them up with
clear_flag32(&flags);
Callers that cannot hard-code how wide the data to be associated
with the commit be at compile time can use the "_with_stride"
variant to initialize the slab.
Suppose you want to give one bit per existing ref, and paint commits
down to find which refs are descendants of each commit. Saying
typedef uint32 bits320[5];
define_commit_slab(flagbits, bits320);
at compile time will still limit your code with hard-coded limit,
because you may find that you have more than 320 refs at runtime.
The code can declare a commit slab "struct flagbits" like this
instead:
define_commit_slab(flagbits, unsigned char);
struct flagbits flags;
and initialize it by:
nrefs = ... count number of refs ...
init_flagbits_with_stride(&flags, (nrefs + 7) / 8);
so that
unsigned char *fp = flagbits_at(&flags, commit);
will return a pointer pointing at an array of 40 "unsigned char"s
associated with the commit, once you figure out nrefs is 320 at
runtime.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-13 18:56:41 +00:00
|
|
|
int *pi = indegree_slab_at(&indegree, parent);
|
2007-11-02 20:32:58 +00:00
|
|
|
|
2013-04-09 06:52:56 +00:00
|
|
|
if (!*pi)
|
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.
|
|
|
|
*/
|
2013-06-07 04:58:12 +00:00
|
|
|
if (--(*pi) == 1)
|
|
|
|
prio_queue_put(&queue, parent);
|
2005-07-06 16:39:34 +00:00
|
|
|
}
|
|
|
|
/*
|
2013-06-07 04:58:12 +00:00
|
|
|
* all children of commit have already been
|
|
|
|
* emitted. we can emit it now.
|
2007-09-10 10:35:06 +00:00
|
|
|
*/
|
commit-slab: introduce a macro to define a slab for new type
Introduce a header file to define a macro that can define the struct
type, initializer, accessor and cleanup functions to manage a commit
slab. Update the "indegree" topological sort facility using it.
To associate 32 flag bits with each commit, you can write:
define_commit_slab(flag32, uint32);
to declare "struct flag32" type, define an instance of it with
struct flag32 flags;
and initialize it by calling
init_flag32(&flags);
After that, a call to flag32_at() function
uint32 *fp = flag32_at(&flags, commit);
will return a pointer pointing at a uint32 for that commit. Once
you are done with these flags, clean them up with
clear_flag32(&flags);
Callers that cannot hard-code how wide the data to be associated
with the commit be at compile time can use the "_with_stride"
variant to initialize the slab.
Suppose you want to give one bit per existing ref, and paint commits
down to find which refs are descendants of each commit. Saying
typedef uint32 bits320[5];
define_commit_slab(flagbits, bits320);
at compile time will still limit your code with hard-coded limit,
because you may find that you have more than 320 refs at runtime.
The code can declare a commit slab "struct flagbits" like this
instead:
define_commit_slab(flagbits, unsigned char);
struct flagbits flags;
and initialize it by:
nrefs = ... count number of refs ...
init_flagbits_with_stride(&flags, (nrefs + 7) / 8);
so that
unsigned char *fp = flagbits_at(&flags, commit);
will return a pointer pointing at an array of 40 "unsigned char"s
associated with the commit, once you figure out nrefs is 320 at
runtime.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-13 18:56:41 +00:00
|
|
|
*(indegree_slab_at(&indegree, commit)) = 0;
|
2013-06-07 04:58:12 +00:00
|
|
|
|
|
|
|
pptr = &commit_list_insert(commit, pptr)->next;
|
2005-07-06 16:39:34 +00:00
|
|
|
}
|
2013-04-09 06:52:56 +00:00
|
|
|
|
commit-slab: introduce a macro to define a slab for new type
Introduce a header file to define a macro that can define the struct
type, initializer, accessor and cleanup functions to manage a commit
slab. Update the "indegree" topological sort facility using it.
To associate 32 flag bits with each commit, you can write:
define_commit_slab(flag32, uint32);
to declare "struct flag32" type, define an instance of it with
struct flag32 flags;
and initialize it by calling
init_flag32(&flags);
After that, a call to flag32_at() function
uint32 *fp = flag32_at(&flags, commit);
will return a pointer pointing at a uint32 for that commit. Once
you are done with these flags, clean them up with
clear_flag32(&flags);
Callers that cannot hard-code how wide the data to be associated
with the commit be at compile time can use the "_with_stride"
variant to initialize the slab.
Suppose you want to give one bit per existing ref, and paint commits
down to find which refs are descendants of each commit. Saying
typedef uint32 bits320[5];
define_commit_slab(flagbits, bits320);
at compile time will still limit your code with hard-coded limit,
because you may find that you have more than 320 refs at runtime.
The code can declare a commit slab "struct flagbits" like this
instead:
define_commit_slab(flagbits, unsigned char);
struct flagbits flags;
and initialize it by:
nrefs = ... count number of refs ...
init_flagbits_with_stride(&flags, (nrefs + 7) / 8);
so that
unsigned char *fp = flagbits_at(&flags, commit);
will return a pointer pointing at an array of 40 "unsigned char"s
associated with the commit, once you figure out nrefs is 320 at
runtime.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-13 18:56:41 +00:00
|
|
|
clear_indegree_slab(&indegree);
|
2013-06-07 04:58:12 +00:00
|
|
|
clear_prio_queue(&queue);
|
2013-06-07 17:35:54 +00:00
|
|
|
if (sort_order == REV_SORT_BY_AUTHOR_DATE)
|
|
|
|
clear_author_date_slab(&author_date);
|
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;
|
|
|
|
}
|
|
|
|
|
2012-10-04 22:37:15 +00:00
|
|
|
/* all input commits in one and twos[] must have been parsed! */
|
2012-08-30 21:39:03 +00:00
|
|
|
static struct commit_list *paint_down_to_common(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
|
|
|
|
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);
|
2012-10-04 22:37:15 +00:00
|
|
|
if (!n)
|
|
|
|
return 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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-01-09 07:10:49 +00:00
|
|
|
free_commit_list(list);
|
2012-08-30 21:39:03 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct commit_list *merge_bases_many(struct commit *one, int n, struct commit **twos)
|
|
|
|
{
|
|
|
|
struct commit_list *list = NULL;
|
|
|
|
struct commit_list *result = NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parse_commit(one))
|
|
|
|
return NULL;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
if (parse_commit(twos[i]))
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
list = paint_down_to_common(one, n, twos);
|
|
|
|
|
2006-07-05 01:46:42 +00:00
|
|
|
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;
|
|
|
|
|
2014-01-03 14:45:46 +00:00
|
|
|
if (!in)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
commit_list_insert(in->item, &ret);
|
|
|
|
|
|
|
|
for (i = in->next; i; i = i->next) {
|
|
|
|
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;
|
2008-06-27 16:22:00 +00:00
|
|
|
}
|
2014-01-03 14:45:46 +00:00
|
|
|
ret = new;
|
2008-06-27 16:22:00 +00:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-30 22:35:39 +00:00
|
|
|
static int remove_redundant(struct commit **array, int cnt)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Some commit in the array may be an ancestor of
|
|
|
|
* another commit. Move such commit to the end of
|
|
|
|
* the array, and return the number of commits that
|
|
|
|
* are independent from each other.
|
|
|
|
*/
|
|
|
|
struct commit **work;
|
|
|
|
unsigned char *redundant;
|
|
|
|
int *filled_index;
|
|
|
|
int i, j, filled;
|
|
|
|
|
|
|
|
work = xcalloc(cnt, sizeof(*work));
|
|
|
|
redundant = xcalloc(cnt, 1);
|
|
|
|
filled_index = xmalloc(sizeof(*filled_index) * (cnt - 1));
|
|
|
|
|
2012-10-04 22:37:15 +00:00
|
|
|
for (i = 0; i < cnt; i++)
|
|
|
|
parse_commit(array[i]);
|
2012-08-30 22:35:39 +00:00
|
|
|
for (i = 0; i < cnt; i++) {
|
|
|
|
struct commit_list *common;
|
|
|
|
|
|
|
|
if (redundant[i])
|
|
|
|
continue;
|
|
|
|
for (j = filled = 0; j < cnt; j++) {
|
|
|
|
if (i == j || redundant[j])
|
|
|
|
continue;
|
|
|
|
filled_index[filled] = j;
|
|
|
|
work[filled++] = array[j];
|
|
|
|
}
|
|
|
|
common = paint_down_to_common(array[i], filled, work);
|
|
|
|
if (array[i]->object.flags & PARENT2)
|
|
|
|
redundant[i] = 1;
|
|
|
|
for (j = 0; j < filled; j++)
|
|
|
|
if (work[j]->object.flags & PARENT1)
|
|
|
|
redundant[filled_index[j]] = 1;
|
|
|
|
clear_commit_marks(array[i], all_flags);
|
|
|
|
for (j = 0; j < filled; j++)
|
|
|
|
clear_commit_marks(work[j], all_flags);
|
|
|
|
free_commit_list(common);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now collect the result */
|
|
|
|
memcpy(work, array, sizeof(*array) * cnt);
|
|
|
|
for (i = filled = 0; i < cnt; i++)
|
|
|
|
if (!redundant[i])
|
|
|
|
array[filled++] = work[i];
|
|
|
|
for (j = filled, i = 0; i < cnt; i++)
|
|
|
|
if (redundant[i])
|
|
|
|
array[j++] = work[i];
|
|
|
|
free(work);
|
|
|
|
free(redundant);
|
|
|
|
free(filled_index);
|
|
|
|
return filled;
|
|
|
|
}
|
|
|
|
|
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;
|
2012-08-30 22:35:39 +00:00
|
|
|
int cnt, i;
|
2006-07-05 01:46:42 +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
|
|
|
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);
|
2013-03-05 19:42:20 +00:00
|
|
|
clear_commit_marks_many(n, twos, 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);
|
2013-03-05 19:42:20 +00:00
|
|
|
clear_commit_marks_many(n, twos, all_flags);
|
2006-06-29 13:17:32 +00:00
|
|
|
|
2012-08-30 22:35:39 +00:00
|
|
|
cnt = remove_redundant(rslt, cnt);
|
2006-07-05 01:46:42 +00:00
|
|
|
result = NULL;
|
2012-08-30 22:35:39 +00:00
|
|
|
for (i = 0; i < cnt; i++)
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2012-08-27 21:46:01 +00:00
|
|
|
/*
|
2013-04-11 22:36:10 +00:00
|
|
|
* Is "commit" a descendant of one of the elements on the "with_commit" list?
|
2012-08-27 21:46:01 +00:00
|
|
|
*/
|
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;
|
2012-08-27 21:46:01 +00:00
|
|
|
if (in_merge_bases(other, commit))
|
2009-01-26 14:13:24 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-27 21:46:01 +00:00
|
|
|
/*
|
2013-03-04 18:16:42 +00:00
|
|
|
* Is "commit" an ancestor of one of the "references"?
|
2012-08-27 21:46:01 +00:00
|
|
|
*/
|
2013-03-04 18:16:42 +00:00
|
|
|
int in_merge_bases_many(struct commit *commit, int nr_reference, struct commit **reference)
|
2006-12-19 08:14:04 +00:00
|
|
|
{
|
2012-08-30 22:04:13 +00:00
|
|
|
struct commit_list *bases;
|
2013-03-04 18:16:42 +00:00
|
|
|
int ret = 0, i;
|
2006-12-19 08:14:04 +00:00
|
|
|
|
2013-03-04 18:16:42 +00:00
|
|
|
if (parse_commit(commit))
|
2012-08-30 22:04:13 +00:00
|
|
|
return ret;
|
2013-03-04 18:16:42 +00:00
|
|
|
for (i = 0; i < nr_reference; i++)
|
|
|
|
if (parse_commit(reference[i]))
|
|
|
|
return ret;
|
2006-12-19 08:14:04 +00:00
|
|
|
|
2013-03-04 18:16:42 +00:00
|
|
|
bases = paint_down_to_common(commit, nr_reference, reference);
|
2012-08-30 22:04:13 +00:00
|
|
|
if (commit->object.flags & PARENT2)
|
|
|
|
ret = 1;
|
2012-08-23 14:20:41 +00:00
|
|
|
clear_commit_marks(commit, all_flags);
|
2013-03-05 19:56:03 +00:00
|
|
|
clear_commit_marks_many(nr_reference, reference, all_flags);
|
2006-12-19 08:14:04 +00:00
|
|
|
free_commit_list(bases);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-06-27 16:22:03 +00:00
|
|
|
|
2013-03-04 18:16:42 +00:00
|
|
|
/*
|
|
|
|
* Is "commit" an ancestor of (i.e. reachable from) the "reference"?
|
|
|
|
*/
|
|
|
|
int in_merge_bases(struct commit *commit, struct commit *reference)
|
|
|
|
{
|
|
|
|
return in_merge_bases_many(commit, 1, &reference);
|
|
|
|
}
|
|
|
|
|
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;
|
2012-08-31 06:20:40 +00:00
|
|
|
struct commit **array;
|
|
|
|
int num_head, i;
|
2008-06-27 16:22:03 +00:00
|
|
|
|
|
|
|
if (!heads)
|
|
|
|
return NULL;
|
|
|
|
|
2012-08-31 06:20:40 +00:00
|
|
|
/* Uniquify */
|
|
|
|
for (p = heads; p; p = p->next)
|
|
|
|
p->item->object.flags &= ~STALE;
|
|
|
|
for (p = heads, num_head = 0; p; p = p->next) {
|
|
|
|
if (p->item->object.flags & STALE)
|
2008-07-14 07:09:41 +00:00
|
|
|
continue;
|
2012-08-31 06:20:40 +00:00
|
|
|
p->item->object.flags |= STALE;
|
|
|
|
num_head++;
|
|
|
|
}
|
|
|
|
array = xcalloc(sizeof(*array), num_head);
|
|
|
|
for (p = heads, i = 0; p; p = p->next) {
|
|
|
|
if (p->item->object.flags & STALE) {
|
|
|
|
array[i++] = p->item;
|
|
|
|
p->item->object.flags &= ~STALE;
|
2008-06-27 16:22:03 +00:00
|
|
|
}
|
|
|
|
}
|
2012-08-31 06:20:40 +00:00
|
|
|
num_head = remove_redundant(array, num_head);
|
|
|
|
for (i = 0; i < num_head; i++)
|
|
|
|
tail = &commit_list_insert(array[i], tail)->next;
|
2008-06-27 16:22:03 +00:00
|
|
|
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
|
|
|
|
commit: teach --gpg-sign option
This uses the gpg-interface.[ch] to allow signing the commit, i.e.
$ git commit --gpg-sign -m foo
You need a passphrase to unlock the secret key for
user: "Junio C Hamano <gitster@pobox.com>"
4096-bit RSA key, ID 96AFE6CB, created 2011-10-03 (main key ID 713660A7)
[master 8457d13] foo
1 files changed, 1 insertions(+), 0 deletions(-)
The lines of GPG detached signature are placed in a new multi-line header
field, instead of tucking the signature block at the end of the commit log
message text (similar to how signed tag is done), for multiple reasons:
- The signature won't clutter output from "git log" and friends if it is
in the extra header. If we place it at the end of the log message, we
would need to teach "git log" and friends to strip the signature block
with an option.
- Teaching new versions of "git log" and "gitk" to optionally verify and
show signatures is cleaner if we structurally know where the signature
block is (instead of scanning in the commit log message).
- The signature needs to be stripped upon various commit rewriting
operations, e.g. rebase, filter-branch, etc. They all already ignore
unknown headers, but if we place signature in the log message, all of
these tools (and third-party tools) also need to learn how a signature
block would look like.
- When we added the optional encoding header, all the tools (both in tree
and third-party) that acts on the raw commit object should have been
fixed to ignore headers they do not understand, so it is not like that
new header would be more likely to break than extra text in the commit.
A commit made with the above sample sequence would look like this:
$ git cat-file commit HEAD
tree 3cd71d90e3db4136e5260ab54599791c4f883b9d
parent b87755351a47b09cb27d6913e6e0e17e6254a4d4
author Junio C Hamano <gitster@pobox.com> 1317862251 -0700
committer Junio C Hamano <gitster@pobox.com> 1317862251 -0700
gpgsig -----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.10 (GNU/Linux)
iQIcBAABAgAGBQJOjPtrAAoJELC16IaWr+bL4TMP/RSe2Y/jYnCkds9unO5JEnfG
...
=dt98
-----END PGP SIGNATURE-----
foo
but "git log" (unless you ask for it with --pretty=raw) output is not
cluttered with the signature information.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-06 00:23:20 +00:00
|
|
|
static const char gpg_sig_header[] = "gpgsig";
|
|
|
|
static const int gpg_sig_header_len = sizeof(gpg_sig_header) - 1;
|
|
|
|
|
|
|
|
static int do_sign_commit(struct strbuf *buf, const char *keyid)
|
|
|
|
{
|
|
|
|
struct strbuf sig = STRBUF_INIT;
|
|
|
|
int inspos, copypos;
|
|
|
|
|
|
|
|
/* find the end of the header */
|
|
|
|
inspos = strstr(buf->buf, "\n\n") - buf->buf + 1;
|
|
|
|
|
|
|
|
if (!keyid || !*keyid)
|
|
|
|
keyid = get_signing_key();
|
|
|
|
if (sign_buffer(buf, &sig, keyid)) {
|
|
|
|
strbuf_release(&sig);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (copypos = 0; sig.buf[copypos]; ) {
|
|
|
|
const char *bol = sig.buf + copypos;
|
|
|
|
const char *eol = strchrnul(bol, '\n');
|
|
|
|
int len = (eol - bol) + !!*eol;
|
|
|
|
|
|
|
|
if (!copypos) {
|
|
|
|
strbuf_insert(buf, inspos, gpg_sig_header, gpg_sig_header_len);
|
|
|
|
inspos += gpg_sig_header_len;
|
|
|
|
}
|
|
|
|
strbuf_insert(buf, inspos++, " ", 1);
|
|
|
|
strbuf_insert(buf, inspos, bol, len);
|
|
|
|
inspos += len;
|
|
|
|
copypos += len;
|
|
|
|
}
|
|
|
|
strbuf_release(&sig);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-10-18 22:53:23 +00:00
|
|
|
int parse_signed_commit(const unsigned char *sha1,
|
|
|
|
struct strbuf *payload, struct strbuf *signature)
|
|
|
|
{
|
|
|
|
unsigned long size;
|
|
|
|
enum object_type type;
|
|
|
|
char *buffer = read_sha1_file(sha1, &type, &size);
|
|
|
|
int in_signature, saw_signature = -1;
|
|
|
|
char *line, *tail;
|
|
|
|
|
|
|
|
if (!buffer || type != OBJ_COMMIT)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
line = buffer;
|
|
|
|
tail = buffer + size;
|
|
|
|
in_signature = 0;
|
|
|
|
saw_signature = 0;
|
|
|
|
while (line < tail) {
|
|
|
|
const char *sig = NULL;
|
|
|
|
char *next = memchr(line, '\n', tail - line);
|
|
|
|
|
|
|
|
next = next ? next + 1 : tail;
|
|
|
|
if (in_signature && line[0] == ' ')
|
|
|
|
sig = line + 1;
|
2013-11-30 20:55:40 +00:00
|
|
|
else if (starts_with(line, gpg_sig_header) &&
|
2011-10-18 22:53:23 +00:00
|
|
|
line[gpg_sig_header_len] == ' ')
|
|
|
|
sig = line + gpg_sig_header_len + 1;
|
|
|
|
if (sig) {
|
|
|
|
strbuf_add(signature, sig, next - sig);
|
|
|
|
saw_signature = 1;
|
|
|
|
in_signature = 1;
|
|
|
|
} else {
|
|
|
|
if (*line == '\n')
|
|
|
|
/* dump the whole remainder of the buffer */
|
|
|
|
next = tail;
|
|
|
|
strbuf_add(payload, line, next - line);
|
|
|
|
in_signature = 0;
|
|
|
|
}
|
|
|
|
line = next;
|
|
|
|
}
|
|
|
|
cleanup:
|
|
|
|
free(buffer);
|
|
|
|
return saw_signature;
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2013-03-31 16:00:14 +00:00
|
|
|
static struct {
|
|
|
|
char result;
|
|
|
|
const char *check;
|
|
|
|
} sigcheck_gpg_status[] = {
|
|
|
|
{ 'G', "\n[GNUPG:] GOODSIG " },
|
|
|
|
{ 'B', "\n[GNUPG:] BADSIG " },
|
2013-03-31 16:02:46 +00:00
|
|
|
{ 'U', "\n[GNUPG:] TRUST_NEVER" },
|
|
|
|
{ 'U', "\n[GNUPG:] TRUST_UNDEFINED" },
|
2013-03-31 16:00:14 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static void parse_gpg_output(struct signature_check *sigc)
|
|
|
|
{
|
|
|
|
const char *buf = sigc->gpg_status;
|
|
|
|
int i;
|
|
|
|
|
2013-03-31 16:01:34 +00:00
|
|
|
/* Iterate over all search strings */
|
2013-03-31 16:00:14 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(sigcheck_gpg_status); i++) {
|
2013-03-31 16:01:34 +00:00
|
|
|
const char *found, *next;
|
|
|
|
|
2014-03-04 21:06:30 +00:00
|
|
|
found = skip_prefix(buf, sigcheck_gpg_status[i].check + 1);
|
|
|
|
if (!found) {
|
2013-03-31 16:01:34 +00:00
|
|
|
found = strstr(buf, sigcheck_gpg_status[i].check);
|
|
|
|
if (!found)
|
|
|
|
continue;
|
|
|
|
found += strlen(sigcheck_gpg_status[i].check);
|
|
|
|
}
|
2013-03-31 16:00:14 +00:00
|
|
|
sigc->result = sigcheck_gpg_status[i].result;
|
2013-03-31 16:02:46 +00:00
|
|
|
/* The trust messages are not followed by key/signer information */
|
|
|
|
if (sigc->result != 'U') {
|
|
|
|
sigc->key = xmemdupz(found, 16);
|
|
|
|
found += 17;
|
|
|
|
next = strchrnul(found, '\n');
|
|
|
|
sigc->signer = xmemdupz(found, next - found);
|
|
|
|
}
|
2013-03-31 16:00:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void check_commit_signature(const struct commit* commit, struct signature_check *sigc)
|
|
|
|
{
|
|
|
|
struct strbuf payload = STRBUF_INIT;
|
|
|
|
struct strbuf signature = STRBUF_INIT;
|
|
|
|
struct strbuf gpg_output = STRBUF_INIT;
|
|
|
|
struct strbuf gpg_status = STRBUF_INIT;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
sigc->result = 'N';
|
|
|
|
|
|
|
|
if (parse_signed_commit(commit->object.sha1,
|
|
|
|
&payload, &signature) <= 0)
|
|
|
|
goto out;
|
|
|
|
status = verify_signed_buffer(payload.buf, payload.len,
|
|
|
|
signature.buf, signature.len,
|
|
|
|
&gpg_output, &gpg_status);
|
|
|
|
if (status && !gpg_output.len)
|
|
|
|
goto out;
|
|
|
|
sigc->gpg_output = strbuf_detach(&gpg_output, NULL);
|
|
|
|
sigc->gpg_status = strbuf_detach(&gpg_status, NULL);
|
|
|
|
parse_gpg_output(sigc);
|
|
|
|
|
|
|
|
out:
|
|
|
|
strbuf_release(&gpg_status);
|
|
|
|
strbuf_release(&gpg_output);
|
|
|
|
strbuf_release(&payload);
|
|
|
|
strbuf_release(&signature);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2011-11-08 00:21:32 +00:00
|
|
|
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');
|
|
|
|
}
|
|
|
|
|
2012-01-05 18:54:14 +00:00
|
|
|
struct commit_extra_header *read_commit_extra_headers(struct commit *commit,
|
|
|
|
const char **exclude)
|
2011-11-08 23:38:07 +00:00
|
|
|
{
|
|
|
|
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)
|
2012-01-05 18:54:14 +00:00
|
|
|
extra = read_commit_extra_header_lines(buffer, size, exclude);
|
2011-11-08 23:38:07 +00:00
|
|
|
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)));
|
|
|
|
}
|
|
|
|
|
2012-01-05 18:54:14 +00:00
|
|
|
static int excluded_header_field(const char *field, size_t len, const char **exclude)
|
|
|
|
{
|
|
|
|
if (!exclude)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
while (*exclude) {
|
|
|
|
size_t xlen = strlen(*exclude);
|
|
|
|
if (len == xlen &&
|
|
|
|
!memcmp(field, *exclude, xlen) && field[xlen] == ' ')
|
|
|
|
return 1;
|
|
|
|
exclude++;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-09-15 20:58:15 +00:00
|
|
|
static struct commit_extra_header *read_commit_extra_header_lines(
|
|
|
|
const char *buffer, size_t size,
|
|
|
|
const char **exclude)
|
2011-11-08 23:38:07 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2012-01-05 18:54:14 +00:00
|
|
|
if (standard_header_field(line, eof - line) ||
|
|
|
|
excluded_header_field(line, eof - line, exclude))
|
2011-11-08 23:38:07 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-22 02:56:41 +00:00
|
|
|
int commit_tree(const struct strbuf *msg, const unsigned char *tree,
|
2011-11-08 00:21:32 +00:00
|
|
|
struct commit_list *parents, unsigned char *ret,
|
commit: teach --gpg-sign option
This uses the gpg-interface.[ch] to allow signing the commit, i.e.
$ git commit --gpg-sign -m foo
You need a passphrase to unlock the secret key for
user: "Junio C Hamano <gitster@pobox.com>"
4096-bit RSA key, ID 96AFE6CB, created 2011-10-03 (main key ID 713660A7)
[master 8457d13] foo
1 files changed, 1 insertions(+), 0 deletions(-)
The lines of GPG detached signature are placed in a new multi-line header
field, instead of tucking the signature block at the end of the commit log
message text (similar to how signed tag is done), for multiple reasons:
- The signature won't clutter output from "git log" and friends if it is
in the extra header. If we place it at the end of the log message, we
would need to teach "git log" and friends to strip the signature block
with an option.
- Teaching new versions of "git log" and "gitk" to optionally verify and
show signatures is cleaner if we structurally know where the signature
block is (instead of scanning in the commit log message).
- The signature needs to be stripped upon various commit rewriting
operations, e.g. rebase, filter-branch, etc. They all already ignore
unknown headers, but if we place signature in the log message, all of
these tools (and third-party tools) also need to learn how a signature
block would look like.
- When we added the optional encoding header, all the tools (both in tree
and third-party) that acts on the raw commit object should have been
fixed to ignore headers they do not understand, so it is not like that
new header would be more likely to break than extra text in the commit.
A commit made with the above sample sequence would look like this:
$ git cat-file commit HEAD
tree 3cd71d90e3db4136e5260ab54599791c4f883b9d
parent b87755351a47b09cb27d6913e6e0e17e6254a4d4
author Junio C Hamano <gitster@pobox.com> 1317862251 -0700
committer Junio C Hamano <gitster@pobox.com> 1317862251 -0700
gpgsig -----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.10 (GNU/Linux)
iQIcBAABAgAGBQJOjPtrAAoJELC16IaWr+bL4TMP/RSe2Y/jYnCkds9unO5JEnfG
...
=dt98
-----END PGP SIGNATURE-----
foo
but "git log" (unless you ask for it with --pretty=raw) output is not
cluttered with the signature information.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-06 00:23:20 +00:00
|
|
|
const char *author, const char *sign_commit)
|
2011-11-08 00:21:32 +00:00
|
|
|
{
|
|
|
|
struct commit_extra_header *extra = NULL, **tail = &extra;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
append_merge_tag_headers(parents, &tail);
|
commit: teach --gpg-sign option
This uses the gpg-interface.[ch] to allow signing the commit, i.e.
$ git commit --gpg-sign -m foo
You need a passphrase to unlock the secret key for
user: "Junio C Hamano <gitster@pobox.com>"
4096-bit RSA key, ID 96AFE6CB, created 2011-10-03 (main key ID 713660A7)
[master 8457d13] foo
1 files changed, 1 insertions(+), 0 deletions(-)
The lines of GPG detached signature are placed in a new multi-line header
field, instead of tucking the signature block at the end of the commit log
message text (similar to how signed tag is done), for multiple reasons:
- The signature won't clutter output from "git log" and friends if it is
in the extra header. If we place it at the end of the log message, we
would need to teach "git log" and friends to strip the signature block
with an option.
- Teaching new versions of "git log" and "gitk" to optionally verify and
show signatures is cleaner if we structurally know where the signature
block is (instead of scanning in the commit log message).
- The signature needs to be stripped upon various commit rewriting
operations, e.g. rebase, filter-branch, etc. They all already ignore
unknown headers, but if we place signature in the log message, all of
these tools (and third-party tools) also need to learn how a signature
block would look like.
- When we added the optional encoding header, all the tools (both in tree
and third-party) that acts on the raw commit object should have been
fixed to ignore headers they do not understand, so it is not like that
new header would be more likely to break than extra text in the commit.
A commit made with the above sample sequence would look like this:
$ git cat-file commit HEAD
tree 3cd71d90e3db4136e5260ab54599791c4f883b9d
parent b87755351a47b09cb27d6913e6e0e17e6254a4d4
author Junio C Hamano <gitster@pobox.com> 1317862251 -0700
committer Junio C Hamano <gitster@pobox.com> 1317862251 -0700
gpgsig -----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.10 (GNU/Linux)
iQIcBAABAgAGBQJOjPtrAAoJELC16IaWr+bL4TMP/RSe2Y/jYnCkds9unO5JEnfG
...
=dt98
-----END PGP SIGNATURE-----
foo
but "git log" (unless you ask for it with --pretty=raw) output is not
cluttered with the signature information.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-06 00:23:20 +00:00
|
|
|
result = commit_tree_extended(msg, tree, parents, ret,
|
|
|
|
author, sign_commit, extra);
|
2011-11-08 00:21:32 +00:00
|
|
|
free_commit_extra_headers(extra);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2012-06-28 18:24:14 +00:00
|
|
|
static int find_invalid_utf8(const char *buf, int len)
|
|
|
|
{
|
|
|
|
int offset = 0;
|
2013-07-04 17:20:34 +00:00
|
|
|
static const unsigned int max_codepoint[] = {
|
|
|
|
0x7f, 0x7ff, 0xffff, 0x10ffff
|
|
|
|
};
|
2012-06-28 18:24:14 +00:00
|
|
|
|
|
|
|
while (len) {
|
|
|
|
unsigned char c = *buf++;
|
|
|
|
int bytes, bad_offset;
|
2013-07-04 17:19:43 +00:00
|
|
|
unsigned int codepoint;
|
2013-07-04 17:20:34 +00:00
|
|
|
unsigned int min_val, max_val;
|
2012-06-28 18:24:14 +00:00
|
|
|
|
|
|
|
len--;
|
|
|
|
offset++;
|
|
|
|
|
|
|
|
/* Simple US-ASCII? No worries. */
|
|
|
|
if (c < 0x80)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
bad_offset = offset-1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Count how many more high bits set: that's how
|
|
|
|
* many more bytes this sequence should have.
|
|
|
|
*/
|
|
|
|
bytes = 0;
|
|
|
|
while (c & 0x40) {
|
|
|
|
c <<= 1;
|
|
|
|
bytes++;
|
|
|
|
}
|
|
|
|
|
2013-07-04 17:19:43 +00:00
|
|
|
/*
|
|
|
|
* Must be between 1 and 3 more bytes. Longer sequences result in
|
|
|
|
* codepoints beyond U+10FFFF, which are guaranteed never to exist.
|
|
|
|
*/
|
|
|
|
if (bytes < 1 || 3 < bytes)
|
2012-06-28 18:24:14 +00:00
|
|
|
return bad_offset;
|
|
|
|
|
|
|
|
/* Do we *have* that many bytes? */
|
|
|
|
if (len < bytes)
|
|
|
|
return bad_offset;
|
|
|
|
|
2013-07-04 17:20:34 +00:00
|
|
|
/*
|
|
|
|
* Place the encoded bits at the bottom of the value and compute the
|
|
|
|
* valid range.
|
|
|
|
*/
|
2013-07-04 17:19:43 +00:00
|
|
|
codepoint = (c & 0x7f) >> bytes;
|
2013-07-04 17:20:34 +00:00
|
|
|
min_val = max_codepoint[bytes-1] + 1;
|
|
|
|
max_val = max_codepoint[bytes];
|
2013-07-04 17:19:43 +00:00
|
|
|
|
2012-06-28 18:24:14 +00:00
|
|
|
offset += bytes;
|
|
|
|
len -= bytes;
|
|
|
|
|
|
|
|
/* And verify that they are good continuation bytes */
|
|
|
|
do {
|
2013-07-04 17:19:43 +00:00
|
|
|
codepoint <<= 6;
|
|
|
|
codepoint |= *buf & 0x3f;
|
2012-06-28 18:24:14 +00:00
|
|
|
if ((*buf++ & 0xc0) != 0x80)
|
|
|
|
return bad_offset;
|
|
|
|
} while (--bytes);
|
|
|
|
|
2013-07-04 17:20:34 +00:00
|
|
|
/* Reject codepoints that are out of range for the sequence length. */
|
|
|
|
if (codepoint < min_val || codepoint > max_val)
|
2013-07-04 17:19:43 +00:00
|
|
|
return bad_offset;
|
|
|
|
/* Surrogates are only for UTF-16 and cannot be encoded in UTF-8. */
|
|
|
|
if ((codepoint & 0x1ff800) == 0xd800)
|
|
|
|
return bad_offset;
|
2013-07-09 11:16:33 +00:00
|
|
|
/* U+xxFFFE and U+xxFFFF are guaranteed non-characters. */
|
2013-08-05 16:52:28 +00:00
|
|
|
if ((codepoint & 0xfffe) == 0xfffe)
|
2013-07-09 11:16:33 +00:00
|
|
|
return bad_offset;
|
|
|
|
/* So are anything in the range U+FDD0..U+FDEF. */
|
|
|
|
if (codepoint >= 0xfdd0 && codepoint <= 0xfdef)
|
2013-07-04 17:19:43 +00:00
|
|
|
return bad_offset;
|
2012-06-28 18:24:14 +00:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This verifies that the buffer is in proper utf8 format.
|
|
|
|
*
|
|
|
|
* If it isn't, it assumes any non-utf8 characters are Latin1,
|
|
|
|
* and does the conversion.
|
|
|
|
*/
|
|
|
|
static int verify_utf8(struct strbuf *buf)
|
|
|
|
{
|
|
|
|
int ok = 1;
|
|
|
|
long pos = 0;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
int bad;
|
|
|
|
unsigned char c;
|
|
|
|
unsigned char replace[2];
|
|
|
|
|
|
|
|
bad = find_invalid_utf8(buf->buf + pos, buf->len - pos);
|
|
|
|
if (bad < 0)
|
|
|
|
return ok;
|
|
|
|
pos += bad;
|
|
|
|
ok = 0;
|
|
|
|
c = buf->buf[pos];
|
|
|
|
strbuf_remove(buf, pos, 1);
|
|
|
|
|
|
|
|
/* We know 'c' must be in the range 128-255 */
|
|
|
|
replace[0] = 0xc0 + (c >> 6);
|
|
|
|
replace[1] = 0x80 + (c & 0x3f);
|
|
|
|
strbuf_insert(buf, pos, replace, 2);
|
|
|
|
pos += 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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[] =
|
2012-06-28 18:24:14 +00:00
|
|
|
"Warning: commit message did not conform to UTF-8.\n"
|
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
|
|
|
"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";
|
|
|
|
|
2013-12-22 02:56:41 +00:00
|
|
|
int commit_tree_extended(const struct strbuf *msg, const unsigned char *tree,
|
2011-11-08 00:21:32 +00:00
|
|
|
struct commit_list *parents, unsigned char *ret,
|
commit: teach --gpg-sign option
This uses the gpg-interface.[ch] to allow signing the commit, i.e.
$ git commit --gpg-sign -m foo
You need a passphrase to unlock the secret key for
user: "Junio C Hamano <gitster@pobox.com>"
4096-bit RSA key, ID 96AFE6CB, created 2011-10-03 (main key ID 713660A7)
[master 8457d13] foo
1 files changed, 1 insertions(+), 0 deletions(-)
The lines of GPG detached signature are placed in a new multi-line header
field, instead of tucking the signature block at the end of the commit log
message text (similar to how signed tag is done), for multiple reasons:
- The signature won't clutter output from "git log" and friends if it is
in the extra header. If we place it at the end of the log message, we
would need to teach "git log" and friends to strip the signature block
with an option.
- Teaching new versions of "git log" and "gitk" to optionally verify and
show signatures is cleaner if we structurally know where the signature
block is (instead of scanning in the commit log message).
- The signature needs to be stripped upon various commit rewriting
operations, e.g. rebase, filter-branch, etc. They all already ignore
unknown headers, but if we place signature in the log message, all of
these tools (and third-party tools) also need to learn how a signature
block would look like.
- When we added the optional encoding header, all the tools (both in tree
and third-party) that acts on the raw commit object should have been
fixed to ignore headers they do not understand, so it is not like that
new header would be more likely to break than extra text in the commit.
A commit made with the above sample sequence would look like this:
$ git cat-file commit HEAD
tree 3cd71d90e3db4136e5260ab54599791c4f883b9d
parent b87755351a47b09cb27d6913e6e0e17e6254a4d4
author Junio C Hamano <gitster@pobox.com> 1317862251 -0700
committer Junio C Hamano <gitster@pobox.com> 1317862251 -0700
gpgsig -----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.10 (GNU/Linux)
iQIcBAABAgAGBQJOjPtrAAoJELC16IaWr+bL4TMP/RSe2Y/jYnCkds9unO5JEnfG
...
=dt98
-----END PGP SIGNATURE-----
foo
but "git log" (unless you ask for it with --pretty=raw) output is not
cluttered with the signature information.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-06 00:23:20 +00:00
|
|
|
const char *author, const char *sign_commit,
|
|
|
|
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);
|
|
|
|
|
2011-12-15 13:47:23 +00:00
|
|
|
if (memchr(msg->buf, '\0', msg->len))
|
|
|
|
return error("a NUL byte in commit log message not allowed.");
|
|
|
|
|
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
|
|
|
/* 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)
|
2012-05-24 23:28:40 +00:00
|
|
|
author = git_author_info(IDENT_STRICT);
|
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, "author %s\n", author);
|
2012-05-24 23:28:40 +00:00
|
|
|
strbuf_addf(&buffer, "committer %s\n", git_committer_info(IDENT_STRICT));
|
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
|
|
|
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 */
|
2011-12-15 13:47:22 +00:00
|
|
|
strbuf_addbuf(&buffer, msg);
|
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
|
|
|
|
|
|
|
/* And check the encoding */
|
2012-06-28 18:24:14 +00:00
|
|
|
if (encoding_is_utf8 && !verify_utf8(&buffer))
|
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
|
|
|
fprintf(stderr, commit_utf8_warn);
|
|
|
|
|
commit: teach --gpg-sign option
This uses the gpg-interface.[ch] to allow signing the commit, i.e.
$ git commit --gpg-sign -m foo
You need a passphrase to unlock the secret key for
user: "Junio C Hamano <gitster@pobox.com>"
4096-bit RSA key, ID 96AFE6CB, created 2011-10-03 (main key ID 713660A7)
[master 8457d13] foo
1 files changed, 1 insertions(+), 0 deletions(-)
The lines of GPG detached signature are placed in a new multi-line header
field, instead of tucking the signature block at the end of the commit log
message text (similar to how signed tag is done), for multiple reasons:
- The signature won't clutter output from "git log" and friends if it is
in the extra header. If we place it at the end of the log message, we
would need to teach "git log" and friends to strip the signature block
with an option.
- Teaching new versions of "git log" and "gitk" to optionally verify and
show signatures is cleaner if we structurally know where the signature
block is (instead of scanning in the commit log message).
- The signature needs to be stripped upon various commit rewriting
operations, e.g. rebase, filter-branch, etc. They all already ignore
unknown headers, but if we place signature in the log message, all of
these tools (and third-party tools) also need to learn how a signature
block would look like.
- When we added the optional encoding header, all the tools (both in tree
and third-party) that acts on the raw commit object should have been
fixed to ignore headers they do not understand, so it is not like that
new header would be more likely to break than extra text in the commit.
A commit made with the above sample sequence would look like this:
$ git cat-file commit HEAD
tree 3cd71d90e3db4136e5260ab54599791c4f883b9d
parent b87755351a47b09cb27d6913e6e0e17e6254a4d4
author Junio C Hamano <gitster@pobox.com> 1317862251 -0700
committer Junio C Hamano <gitster@pobox.com> 1317862251 -0700
gpgsig -----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.10 (GNU/Linux)
iQIcBAABAgAGBQJOjPtrAAoJELC16IaWr+bL4TMP/RSe2Y/jYnCkds9unO5JEnfG
...
=dt98
-----END PGP SIGNATURE-----
foo
but "git log" (unless you ask for it with --pretty=raw) output is not
cluttered with the signature information.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-10-06 00:23:20 +00:00
|
|
|
if (sign_commit && do_sign_commit(&buffer, sign_commit))
|
|
|
|
return -1;
|
|
|
|
|
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
|
|
|
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;
|
|
|
|
}
|
2012-04-25 20:35:27 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Append a commit to the end of the commit_list.
|
|
|
|
*
|
|
|
|
* next starts by pointing to the variable that holds the head of an
|
|
|
|
* empty commit_list, and is updated to point to the "next" field of
|
|
|
|
* the last item on the list as new commits are appended.
|
|
|
|
*
|
|
|
|
* Usage example:
|
|
|
|
*
|
|
|
|
* struct commit_list *list;
|
|
|
|
* struct commit_list **next = &list;
|
|
|
|
*
|
|
|
|
* next = commit_list_append(c1, next);
|
|
|
|
* next = commit_list_append(c2, next);
|
|
|
|
* assert(commit_list_count(list) == 2);
|
|
|
|
* return list;
|
|
|
|
*/
|
|
|
|
struct commit_list **commit_list_append(struct commit *commit,
|
|
|
|
struct commit_list **next)
|
|
|
|
{
|
|
|
|
struct commit_list *new = xmalloc(sizeof(struct commit_list));
|
|
|
|
new->item = commit;
|
|
|
|
*next = new;
|
|
|
|
new->next = NULL;
|
|
|
|
return &new->next;
|
|
|
|
}
|
2012-10-26 15:53:51 +00:00
|
|
|
|
|
|
|
void print_commit_list(struct commit_list *list,
|
|
|
|
const char *format_cur,
|
|
|
|
const char *format_last)
|
|
|
|
{
|
|
|
|
for ( ; list; list = list->next) {
|
|
|
|
const char *format = list->next ? format_cur : format_last;
|
|
|
|
printf(format, sha1_to_hex(list->item->object.sha1));
|
|
|
|
}
|
|
|
|
}
|