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         int found = 0;
 105
 106         if (get_sha1(arg, sha1))
 107                 die("Not a valid object name %s", arg);
 108         cmit = lookup_commit_reference(sha1);
 109         if (!cmit)
 110                 die("%s is not a valid '%s' object", arg, commit_type);
 111
 112         if (!initialized) {
 113                 initialized = 1;
 114                 for_each_ref(get_name, NULL);
 115         }
 116
 117         n = cmit->util;
 118         if (n) {
 119                 printf("%s\n", n->path);
 120                 return;
 121         }
 122
 123         if (debug)
 124                 fprintf(stderr, "searching to describe %s\n", arg);
 125
 126         list = NULL;
 127         cmit->object.flags = SEEN;
 128         commit_list_insert(cmit, &list);
 129         while (list) {
 130                 struct commit *c = pop_commit(&list);
 131                 struct commit_list *parents = c->parents;
 132                 seen_commits++;
 133                 n = c->util;
 134                 if (n) {
 135                         if (match_cnt < max_candidates) {
 136                                 struct possible_tag *t = &all_matches[match_cnt++];
 137                                 t->name = n;
 138                                 t->depth = seen_commits - 1;
 139                                 t->flag_within = 1u << match_cnt;
 140                                 t->found_order = found++;
 141                                 c->object.flags |= t->flag_within;
 142                                 if (n->prio == 2)
 143                                         annotated_cnt++;
 144                         }
 145                         else {
 146                                 gave_up_on = c;
 147                                 break;
 148                         }
 149                 }
 150                 for (cur_match = 0; cur_match < match_cnt; cur_match++) {
 151                         struct possible_tag *t = &all_matches[cur_match];
 152                         if (!(c->object.flags & t->flag_within))
 153                                 t->depth++;
 154                 }
 155                 if (annotated_cnt && !list) {
 156                         if (debug)
 157                                 fprintf(stderr, "finished search at %s\n",
 158                                         sha1_to_hex(c->object.sha1));
 159                         break;
 160                 }
 161                 while (parents) {
 162                         struct commit *p = parents->item;
 163                         parse_commit(p);
 164                         if (!(p->object.flags & SEEN))
 165                                 insert_by_date(p, &list);
 166                         p->object.flags |= c->object.flags;
 167                         parents = parents->next;
 168                 }
 169         }
 170         free_commit_list(list);
 171
 172         if (!match_cnt)
 173                 die("cannot describe '%s'", sha1_to_hex(cmit->object.sha1));
 174
 175         qsort(all_matches, match_cnt, sizeof(all_matches[0]), compare_pt);
 176         if (debug) {
 177                 for (cur_match = 0; cur_match < match_cnt; cur_match++) {
 178                         struct possible_tag *t = &all_matches[cur_match];
 179                         fprintf(stderr, " %-11s %8d %s\n",
 180                                 prio_names[t->name->prio],
 181                                 t->depth, t->name->path);
 182                 }
 183                 fprintf(stderr, "traversed %lu commits\n", seen_commits);
 184                 if (gave_up_on) {
 185                         fprintf(stderr,
 186                                 "more than %i tags found; listed %i most recent\n"
 187                                 "gave up search at %s\n",
 188                                 max_candidates, max_candidates,
 189                                 sha1_to_hex(gave_up_on->object.sha1));
 190                 }
 191         }
 192         printf("%s-g%s\n", all_matches[0].name->path,
 193                    find_unique_abbrev(cmit->object.sha1, abbrev));
 194
 195         if (!last_one)
 196                 clear_commit_marks(cmit, -1);
 197 }
 198
 199 int cmd_describe(int argc, const char **argv, const char *prefix)
 200 {
 201         int i;
 202
 203         for (i = 1; i < argc; i++) {
 204                 const char *arg = argv[i];
 205
 206                 if (*arg != '-')
 207                         break;
 208                 else if (!strcmp(arg, "--debug"))
 209                         debug = 1;
 210                 else if (!strcmp(arg, "--all"))
 211                         all = 1;
 212                 else if (!strcmp(arg, "--tags"))
 213                         tags = 1;
 214                 else if (!strncmp(arg, "--abbrev=", 9)) {
 215                         abbrev = strtoul(arg + 9, NULL, 10);
 216                         if (abbrev < MINIMUM_ABBREV || 40 < abbrev)
 217                                 abbrev = DEFAULT_ABBREV;
 218                 }
 219                 else if (!strncmp(arg, "--candidates=", 13)) {
 220                         max_candidates = strtoul(arg + 13, NULL, 10);
 221                         if (max_candidates < 1)
 222                                 max_candidates = 1;
 223                         else if (max_candidates > MAX_TAGS)
 224                                 max_candidates = MAX_TAGS;
 225                 }
 226                 else
 227                         usage(describe_usage);
 228         }
 229
 230         save_commit_buffer = 0;
 231
 232         if (argc <= i)
 233                 describe("HEAD", 1);
 234         else
 235                 while (i < argc) {
 236                         describe(argv[i], (i == argc - 1));
 237                         i++;
 238                 }
 239
 240         return 0;
 241 }