builtin-describe.c

   1 #include "cache.h"
   2 #include "commit.h"
   3 #include "tag.h"
   4 #include "refs.h"
   5 #include "builtin.h"
   6
   7 #define SEEN            (1u<<0)
   8 #define MAX_TAGS        (FLAG_BITS - 1)
   9
  10 static const char describe_usage[] =
  11 "git-describe [--all] [--tags] [--abbrev=<n>] <committish>*";
  12
  13 static int debug;       /* Display lots of verbose info */
  14 static int all; /* Default to annotated tags only */
  15 static int tags;        /* But allow any tags if --tags is specified */
  16 static int abbrev = DEFAULT_ABBREV;
  17 static int max_candidates = 10;
  18
  19 struct commit_name {
  20         int prio; /* annotated tag = 2, tag = 1, head = 0 */
  21         char path[FLEX_ARRAY]; /* more */
  22 };
  23 static const char *prio_names[] = {
  24         "head", "lightweight", "annotated",
  25 };
  26
  27 static void add_to_known_names(const char *path,
  28                                struct commit *commit,
  29                                int prio)
  30 {
  31         struct commit_name *e = commit->util;
  32         if (!e || e->prio < prio) {
  33                 size_t len = strlen(path)+1;
  34                 free(e);
  35                 e = xmalloc(sizeof(struct commit_name) + len);
  36                 e->prio = prio;
  37                 memcpy(e->path, path, len);
  38                 commit->util = e;
  39         }
  40 }
  41
  42 static int get_name(const char *path, const unsigned char *sha1, int flag, void *cb_data)
  43 {
  44         struct commit *commit = lookup_commit_reference_gently(sha1, 1);
  45         struct object *object;
  46         int prio;
  47
  48         if (!commit)
  49                 return 0;
  50         object = parse_object(sha1);
  51         /* If --all, then any refs are used.
  52          * If --tags, then any tags are used.
  53          * Otherwise only annotated tags are used.
  54          */
  55         if (!strncmp(path, "refs/tags/", 10)) {
  56                 if (object->type == OBJ_TAG)
  57                         prio = 2;
  58                 else
  59                         prio = 1;
  60         }
  61         else
  62                 prio = 0;
  63
  64         if (!all) {
  65                 if (!prio)
  66                         return 0;
  67                 if (!tags && prio < 2)
  68                         return 0;
  69         }
  70         add_to_known_names(all ? path + 5 : path + 10, commit, prio);
  71         return 0;
  72 }
  73
  74 struct possible_tag {
  75         struct commit_name *name;
  76         int depth;
  77         int found_order;
  78         unsigned flag_within;
  79 };
  80
  81 static int compare_pt(const void *a_, const void *b_)
  82 {
  83         struct possible_tag *a = (struct possible_tag *)a_;
  84         struct possible_tag *b = (struct possible_tag *)b_;
  85         if (a->name->prio != b->name->prio)
  86                 return b->name->prio - a->name->prio;
  87         if (a->depth != b->depth)
  88                 return a->depth - b->depth;
  89         if (a->found_order != b->found_order)
  90                 return a->found_order - b->found_order;
  91         return 0;
  92 }
  93
  94 static void describe(const char *arg, int last_one)
  95 {
  96         unsigned char sha1[20];
  97         struct commit *cmit, *gave_up_on = NULL;
  98         struct commit_list *list;
  99         static int initialized = 0;
 100         struct commit_name *n;
 101         struct possible_tag all_matches[MAX_TAGS];
 102         unsigned int match_cnt = 0, annotated_cnt = 0, cur_match;
 103         unsigned long seen_commits = 0;
 104
 105         if (get_sha1(arg, sha1))
 106                 die("Not a valid object name %s", arg);
 107         cmit = lookup_commit_reference(sha1);
 108         if (!cmit)
 109                 die("%s is not a valid '%s' object", arg, commit_type);
 110
 111         if (!initialized) {
 112                 initialized = 1;
 113                 for_each_ref(get_name, NULL);
 114         }
 115
 116         n = cmit->util;
 117         if (n) {
 118                 printf("%s\n", n->path);
 119                 return;
 120         }
 121
 122         if (debug)
 123                 fprintf(stderr, "searching to describe %s\n", arg);
 124
 125         list = NULL;
 126         cmit->object.flags = SEEN;
 127         commit_list_insert(cmit, &list);
 128         while (list) {
 129                 struct commit *c = pop_commit(&list);
 130                 struct commit_list *parents = c->parents;
 131                 seen_commits++;
 132                 n = c->util;
 133                 if (n) {
 134                         if (match_cnt < max_candidates) {
 135                                 struct possible_tag *t = &all_matches[match_cnt++];
 136                                 t->name = n;
 137                                 t->depth = seen_commits - 1;
 138                                 t->flag_within = 1u << match_cnt;
 139                                 t->found_order = match_cnt;
 140                                 c->object.flags |= t->flag_within;
 141                                 if (n->prio == 2)
 142                                         annotated_cnt++;
 143                         }
 144                         else {
 145                                 gave_up_on = c;
 146                                 break;
 147                         }
 148                 }
 149                 for (cur_match = 0; cur_match < match_cnt; cur_match++) {
 150                         struct possible_tag *t = &all_matches[cur_match];
 151                         if (!(c->object.flags & t->flag_within))
 152                                 t->depth++;
 153                 }
 154                 if (annotated_cnt && !list) {
 155                         if (debug)
 156                                 fprintf(stderr, "finished search at %s\n",
 157                                         sha1_to_hex(c->object.sha1));
 158                         break;
 159                 }
 160                 while (parents) {
 161                         struct commit *p = parents->item;
 162                         parse_commit(p);
 163                         if (!(p->object.flags & SEEN))
 164                                 insert_by_date(p, &list);
 165                         p->object.flags |= c->object.flags;
 166                         parents = parents->next;
 167                 }
 168         }
 169         free_commit_list(list);
 170
 171         if (!match_cnt)
 172                 die("cannot describe '%s'", sha1_to_hex(cmit->object.sha1));
 173
 174         qsort(all_matches, match_cnt, sizeof(all_matches[0]), compare_pt);
 175         if (debug) {
 176                 for (cur_match = 0; cur_match < match_cnt; cur_match++) {
 177                         struct possible_tag *t = &all_matches[cur_match];
 178                         fprintf(stderr, " %-11s %8d %s\n",
 179                                 prio_names[t->name->prio],
 180                                 t->depth, t->name->path);
 181                 }
 182                 fprintf(stderr, "traversed %lu commits\n", seen_commits);
 183                 if (gave_up_on) {
 184                         fprintf(stderr,
 185                                 "more than %i tags found; listed %i most recent\n"
 186                                 "gave up search at %s\n",
 187                                 max_candidates, max_candidates,
 188                                 sha1_to_hex(gave_up_on->object.sha1));
 189                 }
 190         }
 191         printf("%s-g%s\n", all_matches[0].name->path,
 192                    find_unique_abbrev(cmit->object.sha1, abbrev));
 193
 194         if (!last_one)
 195                 clear_commit_marks(cmit, -1);
 196 }
 197
 198 int cmd_describe(int argc, const char **argv, const char *prefix)
 199 {
 200         int i;
 201
 202         for (i = 1; i < argc; i++) {
 203                 const char *arg = argv[i];
 204
 205                 if (*arg != '-')
 206                         break;
 207                 else if (!strcmp(arg, "--debug"))
 208                         debug = 1;
 209                 else if (!strcmp(arg, "--all"))
 210                         all = 1;
 211                 else if (!strcmp(arg, "--tags"))
 212                         tags = 1;
 213                 else if (!strncmp(arg, "--abbrev=", 9)) {
 214                         abbrev = strtoul(arg + 9, NULL, 10);
 215                         if (abbrev < MINIMUM_ABBREV || 40 < abbrev)
 216                                 abbrev = DEFAULT_ABBREV;
 217                 }
 218                 else if (!strncmp(arg, "--candidates=", 13)) {
 219                         max_candidates = strtoul(arg + 13, NULL, 10);
 220                         if (max_candidates < 1)
 221                                 max_candidates = 1;
 222                         else if (max_candidates > MAX_TAGS)
 223                                 max_candidates = MAX_TAGS;
 224                 }
 225                 else
 226                         usage(describe_usage);
 227         }
 228
 229         save_commit_buffer = 0;
 230
 231         if (argc <= i)
 232                 describe("HEAD", 1);
 233         else
 234                 while (i < argc) {
 235                         describe(argv[i], (i == argc - 1));
 236                         i++;
 237                 }
 238
 239         return 0;
 240 }