9 #include "parse-options.h"
12 #include "argv-array.h"
13 #include "run-command.h"
15 #define SEEN (1u << 0)
16 #define MAX_TAGS (FLAG_BITS - 1)
18 static const char * const describe_usage
[] = {
19 N_("git describe [<options>] [<commit-ish>...]"),
20 N_("git describe [<options>] --dirty"),
24 static int debug
; /* Display lots of verbose info */
25 static int all
; /* Any valid ref can be used */
26 static int tags
; /* Allow lightweight tags */
27 static int longformat
;
28 static int first_parent
;
29 static int abbrev
= -1; /* unspecified */
30 static int max_candidates
= 10;
31 static struct hashmap names
;
33 static struct string_list patterns
= STRING_LIST_INIT_NODUP
;
34 static struct string_list exclude_patterns
= STRING_LIST_INIT_NODUP
;
36 static const char *suffix
, *dirty
, *broken
;
38 /* diff-index command arguments to check if working tree is dirty. */
39 static const char *diff_index_args
[] = {
40 "diff-index", "--quiet", "HEAD", "--", NULL
44 struct hashmap_entry entry
;
45 struct object_id peeled
;
47 unsigned prio
:2; /* annotated tag = 2, tag = 1, head = 0 */
48 unsigned name_checked
:1;
53 static const char *prio_names
[] = {
54 N_("head"), N_("lightweight"), N_("annotated"),
57 static int commit_name_cmp(const struct commit_name
*cn1
,
58 const struct commit_name
*cn2
, const void *peeled
)
60 return oidcmp(&cn1
->peeled
, peeled
? peeled
: &cn2
->peeled
);
63 static inline struct commit_name
*find_commit_name(const struct object_id
*peeled
)
65 return hashmap_get_from_hash(&names
, sha1hash(peeled
->hash
), peeled
->hash
);
68 static int replace_name(struct commit_name
*e
,
70 const struct object_id
*oid
,
73 if (!e
|| e
->prio
< prio
)
76 if (e
->prio
== 2 && prio
== 2) {
77 /* Multiple annotated tags point to the same commit.
78 * Select one to keep based upon their tagger date.
83 t
= lookup_tag(&e
->oid
);
84 if (!t
|| parse_tag(t
))
90 if (!t
|| parse_tag(t
))
94 if (e
->tag
->date
< t
->date
)
101 static void add_to_known_names(const char *path
,
102 const struct object_id
*peeled
,
104 const struct object_id
*oid
)
106 struct commit_name
*e
= find_commit_name(peeled
);
107 struct tag
*tag
= NULL
;
108 if (replace_name(e
, prio
, oid
, &tag
)) {
110 e
= xmalloc(sizeof(struct commit_name
));
111 oidcpy(&e
->peeled
, peeled
);
112 hashmap_entry_init(e
, sha1hash(peeled
->hash
));
113 hashmap_add(&names
, e
);
119 oidcpy(&e
->oid
, oid
);
121 e
->path
= xstrdup(path
);
125 static int get_name(const char *path
, const struct object_id
*oid
, int flag
, void *cb_data
)
127 int is_tag
= starts_with(path
, "refs/tags/");
128 struct object_id peeled
;
129 int is_annotated
, prio
;
131 /* Reject anything outside refs/tags/ unless --all */
136 * If we're given exclude patterns, first exclude any tag which match
137 * any of the exclude pattern.
139 if (exclude_patterns
.nr
) {
140 struct string_list_item
*item
;
145 for_each_string_list_item(item
, &exclude_patterns
) {
146 if (!wildmatch(item
->string
, path
+ 10, 0))
152 * If we're given patterns, accept only tags which match at least one
156 struct string_list_item
*item
;
161 for_each_string_list_item(item
, &patterns
) {
162 if (!wildmatch(item
->string
, path
+ 10, 0))
165 /* If we get here, no pattern matched. */
170 /* Is it annotated? */
171 if (!peel_ref(path
, peeled
.hash
)) {
172 is_annotated
= !!oidcmp(oid
, &peeled
);
174 oidcpy(&peeled
, oid
);
179 * By default, we only use annotated tags, but with --tags
180 * we fall back to lightweight ones (even without --tags,
181 * we still remember lightweight ones, only to give hints
182 * in an error message). --all allows any refs to be used.
191 add_to_known_names(all
? path
+ 5 : path
+ 10, &peeled
, prio
, oid
);
195 struct possible_tag
{
196 struct commit_name
*name
;
199 unsigned flag_within
;
202 static int compare_pt(const void *a_
, const void *b_
)
204 struct possible_tag
*a
= (struct possible_tag
*)a_
;
205 struct possible_tag
*b
= (struct possible_tag
*)b_
;
206 if (a
->depth
!= b
->depth
)
207 return a
->depth
- b
->depth
;
208 if (a
->found_order
!= b
->found_order
)
209 return a
->found_order
- b
->found_order
;
213 static unsigned long finish_depth_computation(
214 struct commit_list
**list
,
215 struct possible_tag
*best
)
217 unsigned long seen_commits
= 0;
219 struct commit
*c
= pop_commit(list
);
220 struct commit_list
*parents
= c
->parents
;
222 if (c
->object
.flags
& best
->flag_within
) {
223 struct commit_list
*a
= *list
;
225 struct commit
*i
= a
->item
;
226 if (!(i
->object
.flags
& best
->flag_within
))
235 struct commit
*p
= parents
->item
;
237 if (!(p
->object
.flags
& SEEN
))
238 commit_list_insert_by_date(p
, list
);
239 p
->object
.flags
|= c
->object
.flags
;
240 parents
= parents
->next
;
246 static void display_name(struct commit_name
*n
)
248 if (n
->prio
== 2 && !n
->tag
) {
249 n
->tag
= lookup_tag(&n
->oid
);
250 if (!n
->tag
|| parse_tag(n
->tag
))
251 die(_("annotated tag %s not available"), n
->path
);
253 if (n
->tag
&& !n
->name_checked
) {
255 die(_("annotated tag %s has no embedded name"), n
->path
);
256 if (strcmp(n
->tag
->tag
, all
? n
->path
+ 5 : n
->path
))
257 warning(_("tag '%s' is really '%s' here"), n
->tag
->tag
, n
->path
);
262 printf("%s", n
->tag
->tag
);
264 printf("%s", n
->path
);
267 static void show_suffix(int depth
, const struct object_id
*oid
)
269 printf("-%d-g%s", depth
, find_unique_abbrev(oid
->hash
, abbrev
));
272 static void describe(const char *arg
, int last_one
)
274 struct object_id oid
;
275 struct commit
*cmit
, *gave_up_on
= NULL
;
276 struct commit_list
*list
;
277 struct commit_name
*n
;
278 struct possible_tag all_matches
[MAX_TAGS
];
279 unsigned int match_cnt
= 0, annotated_cnt
= 0, cur_match
;
280 unsigned long seen_commits
= 0;
281 unsigned int unannotated_cnt
= 0;
283 if (get_oid(arg
, &oid
))
284 die(_("Not a valid object name %s"), arg
);
285 cmit
= lookup_commit_reference(&oid
);
287 die(_("%s is not a valid '%s' object"), arg
, commit_type
);
289 n
= find_commit_name(&cmit
->object
.oid
);
290 if (n
&& (tags
|| all
|| n
->prio
== 2)) {
292 * Exact match to an existing ref.
296 show_suffix(0, n
->tag
? &n
->tag
->tagged
->oid
: &oid
);
298 printf("%s", suffix
);
304 die(_("no tag exactly matches '%s'"), oid_to_hex(&cmit
->object
.oid
));
306 fprintf(stderr
, _("searching to describe %s\n"), arg
);
309 struct hashmap_iter iter
;
311 struct commit_name
*n
= hashmap_iter_first(&names
, &iter
);
312 for (; n
; n
= hashmap_iter_next(&iter
)) {
313 c
= lookup_commit_reference_gently(&n
->peeled
, 1);
321 cmit
->object
.flags
= SEEN
;
322 commit_list_insert(cmit
, &list
);
324 struct commit
*c
= pop_commit(&list
);
325 struct commit_list
*parents
= c
->parents
;
329 if (!tags
&& !all
&& n
->prio
< 2) {
331 } else if (match_cnt
< max_candidates
) {
332 struct possible_tag
*t
= &all_matches
[match_cnt
++];
334 t
->depth
= seen_commits
- 1;
335 t
->flag_within
= 1u << match_cnt
;
336 t
->found_order
= match_cnt
;
337 c
->object
.flags
|= t
->flag_within
;
346 for (cur_match
= 0; cur_match
< match_cnt
; cur_match
++) {
347 struct possible_tag
*t
= &all_matches
[cur_match
];
348 if (!(c
->object
.flags
& t
->flag_within
))
351 if (annotated_cnt
&& !list
) {
353 fprintf(stderr
, _("finished search at %s\n"),
354 oid_to_hex(&c
->object
.oid
));
358 struct commit
*p
= parents
->item
;
360 if (!(p
->object
.flags
& SEEN
))
361 commit_list_insert_by_date(p
, &list
);
362 p
->object
.flags
|= c
->object
.flags
;
363 parents
= parents
->next
;
371 struct object_id
*oid
= &cmit
->object
.oid
;
373 printf("%s", find_unique_abbrev(oid
->hash
, abbrev
));
375 printf("%s", suffix
);
380 die(_("No annotated tags can describe '%s'.\n"
381 "However, there were unannotated tags: try --tags."),
384 die(_("No tags can describe '%s'.\n"
385 "Try --always, or create some tags."),
389 QSORT(all_matches
, match_cnt
, compare_pt
);
392 commit_list_insert_by_date(gave_up_on
, &list
);
395 seen_commits
+= finish_depth_computation(&list
, &all_matches
[0]);
396 free_commit_list(list
);
399 static int label_width
= -1;
400 if (label_width
< 0) {
402 for (i
= 0; i
< ARRAY_SIZE(prio_names
); i
++) {
403 w
= strlen(_(prio_names
[i
]));
408 for (cur_match
= 0; cur_match
< match_cnt
; cur_match
++) {
409 struct possible_tag
*t
= &all_matches
[cur_match
];
410 fprintf(stderr
, " %-*s %8d %s\n",
411 label_width
, _(prio_names
[t
->name
->prio
]),
412 t
->depth
, t
->name
->path
);
414 fprintf(stderr
, _("traversed %lu commits\n"), seen_commits
);
417 _("more than %i tags found; listed %i most recent\n"
418 "gave up search at %s\n"),
419 max_candidates
, max_candidates
,
420 oid_to_hex(&gave_up_on
->object
.oid
));
424 display_name(all_matches
[0].name
);
426 show_suffix(all_matches
[0].depth
, &cmit
->object
.oid
);
428 printf("%s", suffix
);
432 clear_commit_marks(cmit
, -1);
435 int cmd_describe(int argc
, const char **argv
, const char *prefix
)
438 struct option options
[] = {
439 OPT_BOOL(0, "contains", &contains
, N_("find the tag that comes after the commit")),
440 OPT_BOOL(0, "debug", &debug
, N_("debug search strategy on stderr")),
441 OPT_BOOL(0, "all", &all
, N_("use any ref")),
442 OPT_BOOL(0, "tags", &tags
, N_("use any tag, even unannotated")),
443 OPT_BOOL(0, "long", &longformat
, N_("always use long format")),
444 OPT_BOOL(0, "first-parent", &first_parent
, N_("only follow first parent")),
445 OPT__ABBREV(&abbrev
),
446 OPT_SET_INT(0, "exact-match", &max_candidates
,
447 N_("only output exact matches"), 0),
448 OPT_INTEGER(0, "candidates", &max_candidates
,
449 N_("consider <n> most recent tags (default: 10)")),
450 OPT_STRING_LIST(0, "match", &patterns
, N_("pattern"),
451 N_("only consider tags matching <pattern>")),
452 OPT_STRING_LIST(0, "exclude", &exclude_patterns
, N_("pattern"),
453 N_("do not consider tags matching <pattern>")),
454 OPT_BOOL(0, "always", &always
,
455 N_("show abbreviated commit object as fallback")),
456 {OPTION_STRING
, 0, "dirty", &dirty
, N_("mark"),
457 N_("append <mark> on dirty working tree (default: \"-dirty\")"),
458 PARSE_OPT_OPTARG
, NULL
, (intptr_t) "-dirty"},
459 {OPTION_STRING
, 0, "broken", &broken
, N_("mark"),
460 N_("append <mark> on broken working tree (default: \"-broken\")"),
461 PARSE_OPT_OPTARG
, NULL
, (intptr_t) "-broken"},
465 git_config(git_default_config
, NULL
);
466 argc
= parse_options(argc
, argv
, prefix
, options
, describe_usage
, 0);
468 abbrev
= DEFAULT_ABBREV
;
470 if (max_candidates
< 0)
472 else if (max_candidates
> MAX_TAGS
)
473 max_candidates
= MAX_TAGS
;
475 save_commit_buffer
= 0;
477 if (longformat
&& abbrev
== 0)
478 die(_("--long is incompatible with --abbrev=0"));
481 struct string_list_item
*item
;
482 struct argv_array args
;
484 argv_array_init(&args
);
485 argv_array_pushl(&args
, "name-rev",
486 "--peel-tag", "--name-only", "--no-undefined",
489 argv_array_push(&args
, "--always");
491 argv_array_push(&args
, "--tags");
492 for_each_string_list_item(item
, &patterns
)
493 argv_array_pushf(&args
, "--refs=refs/tags/%s", item
->string
);
494 for_each_string_list_item(item
, &exclude_patterns
)
495 argv_array_pushf(&args
, "--exclude=refs/tags/%s", item
->string
);
498 argv_array_pushv(&args
, argv
);
500 argv_array_push(&args
, "HEAD");
501 return cmd_name_rev(args
.argc
, args
.argv
, prefix
);
504 hashmap_init(&names
, (hashmap_cmp_fn
) commit_name_cmp
, 0);
505 for_each_rawref(get_name
, NULL
);
506 if (!names
.size
&& !always
)
507 die(_("No names found, cannot describe anything."));
511 struct child_process cp
= CHILD_PROCESS_INIT
;
512 argv_array_pushv(&cp
.args
, diff_index_args
);
520 switch (run_command(&cp
)) {
528 /* diff-index aborted abnormally */
532 static struct lock_file index_lock
;
535 read_cache_preload(NULL
);
536 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
,
538 fd
= hold_locked_index(&index_lock
, 0);
540 update_index_if_able(&the_index
, &index_lock
);
542 if (!cmd_diff_index(ARRAY_SIZE(diff_index_args
) - 1,
543 diff_index_args
, prefix
))
550 die(_("--dirty is incompatible with commit-ishes"));
552 die(_("--broken is incompatible with commit-ishes"));
555 describe(*argv
++, argc
== 0);