rev-tree.c

   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
  16 static int show_edges = 0;
  17 static int basemask = 0;
  18
  19 static 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  */
  33 static 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
  54 void 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  */
  78 int 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[2]);
  93                         i++;
  94                         continue;
  95                 }
  96
  97                 if (!strcmp(arg, "--edges")) {
  98                         show_edges = 1;
  99                         continue;
 100                 }
 101
 102                 if (arg[0] == '^') {
 103                         arg++;
 104                         basemask |= 1<<nr;
 105                 }
 106                 if (nr >= MAX_COMMITS || get_sha1_hex(arg, sha1[nr]))
 107                         usage("rev-tree [--edges] [--cache <cache-file>] <commit-id> [<commit-id>]");
 108                 process_commit(sha1[nr]);
 109                 nr++;
 110         }
 111
 112         /*
 113          * Now we have the maximal tree. Walk the different sha files back to the root.
 114          */
 115         for (i = 0; i < nr; i++)
 116                 mark_reachable(&lookup_commit(sha1[i])->object, 1 << i);
 117
 118         /*
 119          * Now print out the results..
 120          */
 121         for (i = 0; i < nr_objs; i++) {
 122                 struct object *obj = objs[i];
 123                 struct commit *commit;
 124                 struct commit_list *p;
 125
 126                 if (obj->type != commit_type)
 127                         continue;
 128
 129                 commit = (struct commit *) obj;
 130
 131                 if (!interesting(commit))
 132                         continue;
 133
 134                 printf("%lu %s:%d", commit->date, sha1_to_hex(obj->sha1),
 135                        obj->flags);
 136                 p = commit->parents;
 137                 while (p) {
 138                         printf(" %s:%d", sha1_to_hex(p->item->object.sha1),
 139                                p->item->object.flags);
 140                         p = p->next;
 141                 }
 142                 printf("\n");
 143         }
 144         return 0;
 145 }