X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=rev-tree.c;h=82bf5aaf9e3f986905c95a5a08a13ed71449ebba;hb=29d76d4b05bc537ac59fd1e6f849ab3386c01502;hp=73c9d1f556103f185e64ff9cffb592c05bd59243;hpb=97d9c3cdeafb9f48075987c76373a71e6874c6eb;p=git.git diff --git a/rev-tree.c b/rev-tree.c index 73c9d1f5..82bf5aaf 100644 --- a/rev-tree.c +++ b/rev-tree.c @@ -1,6 +1,23 @@ +#define _XOPEN_SOURCE /* glibc2 needs this */ +#include +#include #include "cache.h" -#define SEEN 1 +/* + * The low 16 bits of the "flags" field shows whether + * a commit is part of the path to the root for that + * parent. + * + * Bit 16 is an internal flag that we've seen the + * definition for this rev, and not just seen it as + * a parent target. + */ +#define MAX_COMMITS (16) +#define marked(rev) ((rev)->flags & 0xffff) +#define SEEN 0x10000 + +static int show_edges = 0; +static int basemask = 0; struct parent { struct revision *parent; @@ -10,6 +27,7 @@ struct parent { struct revision { unsigned int flags; unsigned char sha1[20]; + unsigned long date; struct parent *parent; }; @@ -83,6 +101,52 @@ static int add_relationship(struct revision *rev, unsigned char *parent_sha) return 1; } +static unsigned long parse_time(const char *buf) +{ + char c, *p; + char buffer[100]; + struct tm tm; + const char *formats[] = { + "%c", + "%a %b %d %T %y", + NULL + }; + const char **fmt = formats; + + p = buffer; + while (isspace(c = *buf)) + buf++; + while ((c = *buf++) != '\n') + *p++ = c; + *p++ = 0; + buf = buffer; + memset(&tm, 0, sizeof(tm)); + do { + const char *next = strptime(buf, *fmt, &tm); + fmt++; + if (next) { + if (!*next) + return mktime(&tm); + buf = next; + } + } while (*buf && *fmt); + return mktime(&tm); +} + + +static unsigned long parse_commit_date(const char *buf) +{ + if (memcmp(buf, "author", 6)) + return 0; + while (*buf++ != '\n') + /* nada */; + if (memcmp(buf, "committer", 9)) + return 0; + while (*buf++ != '>') + /* nada */; + return parse_time(buf); +} + static int parse_commit(unsigned char *sha1) { struct revision *rev = lookup_rev(sha1); @@ -103,6 +167,8 @@ static int parse_commit(unsigned char *sha1) parse_commit(parent); buffer += 48; /* "parent " + "hex sha1" + "\n" */ } + rev->date = parse_commit_date(buffer); + free(buffer); } return 0; } @@ -110,19 +176,86 @@ static int parse_commit(unsigned char *sha1) static void read_cache_file(const char *path) { FILE *file = fopen(path, "r"); - char line[100]; + char line[500]; + + if (!file) + usage("bad revtree cache file (%s)", path); while (fgets(line, sizeof(line), file)) { - unsigned char sha1[20], parent[20]; - if (get_sha1_hex(line, sha1) || get_sha1_hex(line + 41, parent)) - usage("bad rev-tree cache file %s", path); - add_relationship(lookup_rev(sha1), parent); + unsigned long date; + unsigned char sha1[20]; + struct revision *rev; + const char *buf; + + if (sscanf(line, "%lu", &date) != 1) + break; + buf = strchr(line, ' '); + if (!buf) + break; + if (get_sha1_hex(buf+1, sha1)) + break; + rev = lookup_rev(sha1); + rev->flags |= SEEN; + rev->date = date; + + /* parents? */ + while ((buf = strchr(buf+1, ' ')) != NULL) { + unsigned char parent[20]; + if (get_sha1_hex(buf + 1, parent)) + break; + add_relationship(rev, parent); + } } fclose(file); } +static void mark_sha1_path(struct revision *rev, unsigned int mask) +{ + struct parent *p; + + if (rev->flags & mask) + return; + + rev->flags |= mask; + p = rev->parent; + while (p) { + mark_sha1_path(p->parent, mask); + p = p->next; + } +} + /* - * Usage: rev-tree [--cache ] + * Some revisions are less interesting than others. + * + * For example, if we use a cache-file, that one may contain + * revisions that were never used. They are never interesting. + * + * And sometimes we're only interested in "edge" commits, ie + * places where the marking changes between parent and child. + */ +static int interesting(struct revision *rev) +{ + unsigned mask = marked(rev); + + if (!mask) + return 0; + if (show_edges) { + struct parent *p = rev->parent; + while (p) { + if (mask != marked(p->parent)) + return 1; + p = p->next; + } + return 0; + } + if (mask & basemask) + return 0; + + return 1; +} + +/* + * Usage: rev-tree [--edges] [--cache ] [] * * The cache-file can be quite important for big trees. This is an * expensive operation if you have to walk the whole chain of @@ -131,29 +264,57 @@ static void read_cache_file(const char *path) int main(int argc, char **argv) { int i; - unsigned char sha1[20]; + int nr = 0; + unsigned char sha1[MAX_COMMITS][20]; - while (argc > 2) { - if (!strcmp(argv[1], "--cache")) { + /* + * First - pick up all the revisions we can (both from + * caches and from commit file chains). + */ + for (i = 1; i < argc ; i++) { + char *arg = argv[i]; + + if (!strcmp(arg, "--cache")) { read_cache_file(argv[2]); - argv += 2; - argc -= 2; + i++; + continue; + } + + if (!strcmp(arg, "--edges")) { + show_edges = 1; continue; } - usage("unknown option %s", argv[1]); + + if (arg[0] == '^') { + arg++; + basemask |= 1<= MAX_COMMITS || get_sha1_hex(arg, sha1[nr])) + usage("rev-tree [--edges] [--cache ] []"); + parse_commit(sha1[nr]); + nr++; } - if (argc != 2 || get_sha1_hex(argv[1], sha1)) - usage("rev-tree [--cache ] "); - parse_commit(sha1); + /* + * Now we have the maximal tree. Walk the different sha files back to the root. + */ + for (i = 0; i < nr; i++) + mark_sha1_path(lookup_rev(sha1[i]), 1 << i); + + /* + * Now print out the results.. + */ for (i = 0; i < nr_revs; i++) { struct revision *rev = revs[i]; struct parent *p; - printf("%s", sha1_to_hex(rev->sha1)); + if (!interesting(rev)) + continue; + + printf("%lu %s:%d", rev->date, sha1_to_hex(rev->sha1), marked(rev)); p = rev->parent; while (p) { - printf(" %s", sha1_to_hex(p->parent->sha1)); + printf(" %s:%d", sha1_to_hex(p->parent->sha1), marked(p->parent)); p = p->next; } printf("\n");