Andrew's git - gitweb.git/blob

03c900f459c0e6ae7fc9455589be00375f44eac8
   1#define _XOPEN_SOURCE /* glibc2 needs this */
   2#define _BSD_SOURCE /* for tm.tm_gmtoff */
   3#include <time.h>
   4#include <ctype.h>
   5
   6#include "cache.h"
   7#include "commit.h"
   8
   9/*
  10 * revision.h leaves the low 16 bits of the "flags" field of the
  11 * revision data structure unused. We use it for a "reachable from
  12 * this commit <N>" bitmask.
  13 */
  14#define MAX_COMMITS 16
  15
  16static int show_edges = 0;
  17static int basemask = 0;
  18
  19static void read_cache_file(const char *path)
  20{
  21        die("no revtree cache file yet");
  22}
  23
  24/*
  25 * Some revisions are less interesting than others.
  26 *
  27 * For example, if we use a cache-file, that one may contain
  28 * revisions that were never used. They are never interesting.
  29 *
  30 * And sometimes we're only interested in "edge" commits, ie
  31 * places where the marking changes between parent and child.
  32 */
  33static int interesting(struct commit *rev)
  34{
  35        unsigned mask = rev->object.flags;
  36
  37        if (!mask)
  38                return 0;
  39        if (show_edges) {
  40                struct commit_list *p = rev->parents;
  41                while (p) {
  42                        if (mask != p->item->object.flags)
  43                                return 1;
  44                        p = p->next;
  45                }
  46                return 0;
  47        }
  48        if (mask & basemask)
  49                return 0;
  50
  51        return 1;
  52}
  53
  54void process_commit(unsigned char *sha1)
  55{
  56        struct commit_list *parents;
  57        struct commit *obj = lookup_commit(sha1);
  58
  59        if (obj->object.parsed)
  60                return;
  61
  62        parse_commit(obj);
  63        
  64        parents = obj->parents;
  65        while (parents) {
  66                process_commit(parents->item->object.sha1);
  67                parents = parents->next;
  68        }
  69}
  70
  71/*
  72 * Usage: rev-tree [--edges] [--cache <cache-file>] <commit-id> [<commit-id2>]
  73 *
  74 * The cache-file can be quite important for big trees. This is an
  75 * expensive operation if you have to walk the whole chain of
  76 * parents in a tree with a long revision history.
  77 */
  78int main(int argc, char **argv)
  79{
  80        int i;
  81        int nr = 0;
  82        unsigned char sha1[MAX_COMMITS][20];
  83
  84        /*
  85         * First - pick up all the revisions we can (both from
  86         * caches and from commit file chains).
  87         */
  88        for (i = 1; i < argc ; i++) {
  89                char *arg = argv[i];
  90
  91                if (!strcmp(arg, "--cache")) {
  92                        read_cache_file(argv[++i]);
  93                        continue;
  94                }
  95
  96                if (!strcmp(arg, "--edges")) {
  97                        show_edges = 1;
  98                        continue;
  99                }
 100
 101                if (arg[0] == '^') {
 102                        arg++;
 103                        basemask |= 1<<nr;
 104                }
 105                if (nr >= MAX_COMMITS || get_sha1_hex(arg, sha1[nr]))
 106                        usage("rev-tree [--edges] [--cache <cache-file>] <commit-id> [<commit-id>]");
 107                process_commit(sha1[nr]);
 108                nr++;
 109        }
 110
 111        /*
 112         * Now we have the maximal tree. Walk the different sha files back to the root.
 113         */
 114        for (i = 0; i < nr; i++)
 115                mark_reachable(&lookup_commit(sha1[i])->object, 1 << i);
 116
 117        /*
 118         * Now print out the results..
 119         */
 120        for (i = 0; i < nr_objs; i++) {
 121                struct object *obj = objs[i];
 122                struct commit *commit;
 123                struct commit_list *p;
 124
 125                if (obj->type != commit_type)
 126                        continue;
 127
 128                commit = (struct commit *) obj;
 129
 130                if (!interesting(commit))
 131                        continue;
 132
 133                printf("%lu %s:%d", commit->date, sha1_to_hex(obj->sha1), 
 134                       obj->flags);
 135                p = commit->parents;
 136                while (p) {
 137                        printf(" %s:%d", sha1_to_hex(p->item->object.sha1), 
 138                               p->item->object.flags);
 139                        p = p->next;
 140                }
 141                printf("\n");
 142        }
 143        return 0;
 144}