Make sure git_connect() always give two file descriptors.
[git] / 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 }