Andrew's git - gitweb.git/blob - 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
  10static const char describe_usage[] =
  11"git-describe [--all] [--tags] [--abbrev=<n>] <committish>*";
  12
  13static int debug;       /* Display lots of verbose info */
  14static int all; /* Default to annotated tags only */
  15static int tags;        /* But allow any tags if --tags is specified */
  16static int abbrev = DEFAULT_ABBREV;
  17static int max_candidates = 10;
  18
  19struct commit_name {
  20        int prio; /* annotated tag = 2, tag = 1, head = 0 */
  21        char path[FLEX_ARRAY]; /* more */
  22};
  23static const char *prio_names[] = {
  24        "head", "lightweight", "annotated",
  25};
  26
  27static 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
  42static 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
  74struct possible_tag {
  75        struct commit_name *name;
  76        int depth;
  77        int found_order;
  78        unsigned flag_within;
  79};
  80
  81static 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
  94static 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
 199int 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}