Merge branch 'rs/diff-parseopts-cleanup'
[git/gitster.git] / revision.c
blob7e45f765d9fe16c8380f457c0d40e385cbf88f55
1 #include "git-compat-util.h"
2 #include "config.h"
3 #include "environment.h"
4 #include "gettext.h"
5 #include "hex.h"
6 #include "object-name.h"
7 #include "object-file.h"
8 #include "object-store-ll.h"
9 #include "oidset.h"
10 #include "tag.h"
11 #include "blob.h"
12 #include "tree.h"
13 #include "commit.h"
14 #include "diff.h"
15 #include "diff-merges.h"
16 #include "refs.h"
17 #include "revision.h"
18 #include "repository.h"
19 #include "graph.h"
20 #include "grep.h"
21 #include "reflog-walk.h"
22 #include "patch-ids.h"
23 #include "decorate.h"
24 #include "string-list.h"
25 #include "line-log.h"
26 #include "mailmap.h"
27 #include "commit-slab.h"
28 #include "cache-tree.h"
29 #include "bisect.h"
30 #include "packfile.h"
31 #include "worktree.h"
32 #include "read-cache.h"
33 #include "setup.h"
34 #include "sparse-index.h"
35 #include "strvec.h"
36 #include "trace2.h"
37 #include "commit-reach.h"
38 #include "commit-graph.h"
39 #include "prio-queue.h"
40 #include "hashmap.h"
41 #include "utf8.h"
42 #include "bloom.h"
43 #include "json-writer.h"
44 #include "list-objects-filter-options.h"
45 #include "resolve-undo.h"
46 #include "parse-options.h"
47 #include "wildmatch.h"
49 volatile show_early_output_fn_t show_early_output;
51 static const char *term_bad;
52 static const char *term_good;
54 implement_shared_commit_slab(revision_sources, char *);
56 static inline int want_ancestry(const struct rev_info *revs);
58 void show_object_with_name(FILE *out, struct object *obj, const char *name)
60 fprintf(out, "%s ", oid_to_hex(&obj->oid));
61 for (const char *p = name; *p && *p != '\n'; p++)
62 fputc(*p, out);
63 fputc('\n', out);
66 static void mark_blob_uninteresting(struct blob *blob)
68 if (!blob)
69 return;
70 if (blob->object.flags & UNINTERESTING)
71 return;
72 blob->object.flags |= UNINTERESTING;
75 static void mark_tree_contents_uninteresting(struct repository *r,
76 struct tree *tree)
78 struct tree_desc desc;
79 struct name_entry entry;
81 if (parse_tree_gently(tree, 1) < 0)
82 return;
84 init_tree_desc(&desc, &tree->object.oid, tree->buffer, tree->size);
85 while (tree_entry(&desc, &entry)) {
86 switch (object_type(entry.mode)) {
87 case OBJ_TREE:
88 mark_tree_uninteresting(r, lookup_tree(r, &entry.oid));
89 break;
90 case OBJ_BLOB:
91 mark_blob_uninteresting(lookup_blob(r, &entry.oid));
92 break;
93 default:
94 /* Subproject commit - not in this repository */
95 break;
100 * We don't care about the tree any more
101 * after it has been marked uninteresting.
103 free_tree_buffer(tree);
106 void mark_tree_uninteresting(struct repository *r, struct tree *tree)
108 struct object *obj;
110 if (!tree)
111 return;
113 obj = &tree->object;
114 if (obj->flags & UNINTERESTING)
115 return;
116 obj->flags |= UNINTERESTING;
117 mark_tree_contents_uninteresting(r, tree);
120 struct path_and_oids_entry {
121 struct hashmap_entry ent;
122 char *path;
123 struct oidset trees;
126 static int path_and_oids_cmp(const void *hashmap_cmp_fn_data UNUSED,
127 const struct hashmap_entry *eptr,
128 const struct hashmap_entry *entry_or_key,
129 const void *keydata UNUSED)
131 const struct path_and_oids_entry *e1, *e2;
133 e1 = container_of(eptr, const struct path_and_oids_entry, ent);
134 e2 = container_of(entry_or_key, const struct path_and_oids_entry, ent);
136 return strcmp(e1->path, e2->path);
139 static void paths_and_oids_clear(struct hashmap *map)
141 struct hashmap_iter iter;
142 struct path_and_oids_entry *entry;
144 hashmap_for_each_entry(map, &iter, entry, ent /* member name */) {
145 oidset_clear(&entry->trees);
146 free(entry->path);
149 hashmap_clear_and_free(map, struct path_and_oids_entry, ent);
152 static void paths_and_oids_insert(struct hashmap *map,
153 const char *path,
154 const struct object_id *oid)
156 int hash = strhash(path);
157 struct path_and_oids_entry key;
158 struct path_and_oids_entry *entry;
160 hashmap_entry_init(&key.ent, hash);
162 /* use a shallow copy for the lookup */
163 key.path = (char *)path;
164 oidset_init(&key.trees, 0);
166 entry = hashmap_get_entry(map, &key, ent, NULL);
167 if (!entry) {
168 CALLOC_ARRAY(entry, 1);
169 hashmap_entry_init(&entry->ent, hash);
170 entry->path = xstrdup(key.path);
171 oidset_init(&entry->trees, 16);
172 hashmap_put(map, &entry->ent);
175 oidset_insert(&entry->trees, oid);
178 static void add_children_by_path(struct repository *r,
179 struct tree *tree,
180 struct hashmap *map)
182 struct tree_desc desc;
183 struct name_entry entry;
185 if (!tree)
186 return;
188 if (parse_tree_gently(tree, 1) < 0)
189 return;
191 init_tree_desc(&desc, &tree->object.oid, tree->buffer, tree->size);
192 while (tree_entry(&desc, &entry)) {
193 switch (object_type(entry.mode)) {
194 case OBJ_TREE:
195 paths_and_oids_insert(map, entry.path, &entry.oid);
197 if (tree->object.flags & UNINTERESTING) {
198 struct tree *child = lookup_tree(r, &entry.oid);
199 if (child)
200 child->object.flags |= UNINTERESTING;
202 break;
203 case OBJ_BLOB:
204 if (tree->object.flags & UNINTERESTING) {
205 struct blob *child = lookup_blob(r, &entry.oid);
206 if (child)
207 child->object.flags |= UNINTERESTING;
209 break;
210 default:
211 /* Subproject commit - not in this repository */
212 break;
216 free_tree_buffer(tree);
219 void mark_trees_uninteresting_sparse(struct repository *r,
220 struct oidset *trees)
222 unsigned has_interesting = 0, has_uninteresting = 0;
223 struct hashmap map = HASHMAP_INIT(path_and_oids_cmp, NULL);
224 struct hashmap_iter map_iter;
225 struct path_and_oids_entry *entry;
226 struct object_id *oid;
227 struct oidset_iter iter;
229 oidset_iter_init(trees, &iter);
230 while ((!has_interesting || !has_uninteresting) &&
231 (oid = oidset_iter_next(&iter))) {
232 struct tree *tree = lookup_tree(r, oid);
234 if (!tree)
235 continue;
237 if (tree->object.flags & UNINTERESTING)
238 has_uninteresting = 1;
239 else
240 has_interesting = 1;
243 /* Do not walk unless we have both types of trees. */
244 if (!has_uninteresting || !has_interesting)
245 return;
247 oidset_iter_init(trees, &iter);
248 while ((oid = oidset_iter_next(&iter))) {
249 struct tree *tree = lookup_tree(r, oid);
250 add_children_by_path(r, tree, &map);
253 hashmap_for_each_entry(&map, &map_iter, entry, ent /* member name */)
254 mark_trees_uninteresting_sparse(r, &entry->trees);
256 paths_and_oids_clear(&map);
259 struct commit_stack {
260 struct commit **items;
261 size_t nr, alloc;
263 #define COMMIT_STACK_INIT { 0 }
265 static void commit_stack_push(struct commit_stack *stack, struct commit *commit)
267 ALLOC_GROW(stack->items, stack->nr + 1, stack->alloc);
268 stack->items[stack->nr++] = commit;
271 static struct commit *commit_stack_pop(struct commit_stack *stack)
273 return stack->nr ? stack->items[--stack->nr] : NULL;
276 static void commit_stack_clear(struct commit_stack *stack)
278 FREE_AND_NULL(stack->items);
279 stack->nr = stack->alloc = 0;
282 static void mark_one_parent_uninteresting(struct rev_info *revs, struct commit *commit,
283 struct commit_stack *pending)
285 struct commit_list *l;
287 if (commit->object.flags & UNINTERESTING)
288 return;
289 commit->object.flags |= UNINTERESTING;
292 * Normally we haven't parsed the parent
293 * yet, so we won't have a parent of a parent
294 * here. However, it may turn out that we've
295 * reached this commit some other way (where it
296 * wasn't uninteresting), in which case we need
297 * to mark its parents recursively too..
299 for (l = commit->parents; l; l = l->next) {
300 commit_stack_push(pending, l->item);
301 if (revs && revs->exclude_first_parent_only)
302 break;
306 void mark_parents_uninteresting(struct rev_info *revs, struct commit *commit)
308 struct commit_stack pending = COMMIT_STACK_INIT;
309 struct commit_list *l;
311 for (l = commit->parents; l; l = l->next) {
312 mark_one_parent_uninteresting(revs, l->item, &pending);
313 if (revs && revs->exclude_first_parent_only)
314 break;
317 while (pending.nr > 0)
318 mark_one_parent_uninteresting(revs, commit_stack_pop(&pending),
319 &pending);
321 commit_stack_clear(&pending);
324 static void add_pending_object_with_path(struct rev_info *revs,
325 struct object *obj,
326 const char *name, unsigned mode,
327 const char *path)
329 struct interpret_branch_name_options options = { 0 };
330 if (!obj)
331 return;
332 if (revs->no_walk && (obj->flags & UNINTERESTING))
333 revs->no_walk = 0;
334 if (revs->reflog_info && obj->type == OBJ_COMMIT) {
335 struct strbuf buf = STRBUF_INIT;
336 size_t namelen = strlen(name);
337 int len = repo_interpret_branch_name(the_repository, name,
338 namelen, &buf, &options);
340 if (0 < len && len < namelen && buf.len)
341 strbuf_addstr(&buf, name + len);
342 add_reflog_for_walk(revs->reflog_info,
343 (struct commit *)obj,
344 buf.buf[0] ? buf.buf: name);
345 strbuf_release(&buf);
346 return; /* do not add the commit itself */
348 add_object_array_with_path(obj, name, &revs->pending, mode, path);
351 static void add_pending_object_with_mode(struct rev_info *revs,
352 struct object *obj,
353 const char *name, unsigned mode)
355 add_pending_object_with_path(revs, obj, name, mode, NULL);
358 void add_pending_object(struct rev_info *revs,
359 struct object *obj, const char *name)
361 add_pending_object_with_mode(revs, obj, name, S_IFINVALID);
364 void add_head_to_pending(struct rev_info *revs)
366 struct object_id oid;
367 struct object *obj;
368 if (repo_get_oid(the_repository, "HEAD", &oid))
369 return;
370 obj = parse_object(revs->repo, &oid);
371 if (!obj)
372 return;
373 add_pending_object(revs, obj, "HEAD");
376 static struct object *get_reference(struct rev_info *revs, const char *name,
377 const struct object_id *oid,
378 unsigned int flags)
380 struct object *object;
382 object = parse_object_with_flags(revs->repo, oid,
383 revs->verify_objects ? 0 :
384 PARSE_OBJECT_SKIP_HASH_CHECK |
385 PARSE_OBJECT_DISCARD_TREE);
387 if (!object) {
388 if (revs->ignore_missing)
389 return NULL;
390 if (revs->exclude_promisor_objects && is_promisor_object(oid))
391 return NULL;
392 if (revs->do_not_die_on_missing_objects) {
393 oidset_insert(&revs->missing_commits, oid);
394 return NULL;
396 die("bad object %s", name);
398 object->flags |= flags;
399 return object;
402 void add_pending_oid(struct rev_info *revs, const char *name,
403 const struct object_id *oid, unsigned int flags)
405 struct object *object = get_reference(revs, name, oid, flags);
406 add_pending_object(revs, object, name);
409 static struct commit *handle_commit(struct rev_info *revs,
410 struct object_array_entry *entry)
412 struct object *object = entry->item;
413 const char *name = entry->name;
414 const char *path = entry->path;
415 unsigned int mode = entry->mode;
416 unsigned long flags = object->flags;
419 * Tag object? Look what it points to..
421 while (object->type == OBJ_TAG) {
422 struct tag *tag = (struct tag *) object;
423 struct object_id *oid;
424 if (revs->tag_objects && !(flags & UNINTERESTING))
425 add_pending_object(revs, object, tag->tag);
426 oid = get_tagged_oid(tag);
427 object = parse_object(revs->repo, oid);
428 if (!object) {
429 if (revs->ignore_missing_links || (flags & UNINTERESTING))
430 return NULL;
431 if (revs->exclude_promisor_objects &&
432 is_promisor_object(&tag->tagged->oid))
433 return NULL;
434 if (revs->do_not_die_on_missing_objects && oid) {
435 oidset_insert(&revs->missing_commits, oid);
436 return NULL;
438 die("bad object %s", oid_to_hex(&tag->tagged->oid));
440 object->flags |= flags;
442 * We'll handle the tagged object by looping or dropping
443 * through to the non-tag handlers below. Do not
444 * propagate path data from the tag's pending entry.
446 path = NULL;
447 mode = 0;
451 * Commit object? Just return it, we'll do all the complex
452 * reachability crud.
454 if (object->type == OBJ_COMMIT) {
455 struct commit *commit = (struct commit *)object;
457 if (repo_parse_commit(revs->repo, commit) < 0)
458 die("unable to parse commit %s", name);
459 if (flags & UNINTERESTING) {
460 mark_parents_uninteresting(revs, commit);
462 if (!revs->topo_order || !generation_numbers_enabled(the_repository))
463 revs->limited = 1;
465 if (revs->sources) {
466 char **slot = revision_sources_at(revs->sources, commit);
468 if (!*slot)
469 *slot = xstrdup(name);
471 return commit;
475 * Tree object? Either mark it uninteresting, or add it
476 * to the list of objects to look at later..
478 if (object->type == OBJ_TREE) {
479 struct tree *tree = (struct tree *)object;
480 if (!revs->tree_objects)
481 return NULL;
482 if (flags & UNINTERESTING) {
483 mark_tree_contents_uninteresting(revs->repo, tree);
484 return NULL;
486 add_pending_object_with_path(revs, object, name, mode, path);
487 return NULL;
491 * Blob object? You know the drill by now..
493 if (object->type == OBJ_BLOB) {
494 if (!revs->blob_objects)
495 return NULL;
496 if (flags & UNINTERESTING)
497 return NULL;
498 add_pending_object_with_path(revs, object, name, mode, path);
499 return NULL;
501 die("%s is unknown object", name);
504 static int everybody_uninteresting(struct commit_list *orig,
505 struct commit **interesting_cache)
507 struct commit_list *list = orig;
509 if (*interesting_cache) {
510 struct commit *commit = *interesting_cache;
511 if (!(commit->object.flags & UNINTERESTING))
512 return 0;
515 while (list) {
516 struct commit *commit = list->item;
517 list = list->next;
518 if (commit->object.flags & UNINTERESTING)
519 continue;
521 *interesting_cache = commit;
522 return 0;
524 return 1;
528 * A definition of "relevant" commit that we can use to simplify limited graphs
529 * by eliminating side branches.
531 * A "relevant" commit is one that is !UNINTERESTING (ie we are including it
532 * in our list), or that is a specified BOTTOM commit. Then after computing
533 * a limited list, during processing we can generally ignore boundary merges
534 * coming from outside the graph, (ie from irrelevant parents), and treat
535 * those merges as if they were single-parent. TREESAME is defined to consider
536 * only relevant parents, if any. If we are TREESAME to our on-graph parents,
537 * we don't care if we were !TREESAME to non-graph parents.
539 * Treating bottom commits as relevant ensures that a limited graph's
540 * connection to the actual bottom commit is not viewed as a side branch, but
541 * treated as part of the graph. For example:
543 * ....Z...A---X---o---o---B
544 * . /
545 * W---Y
547 * When computing "A..B", the A-X connection is at least as important as
548 * Y-X, despite A being flagged UNINTERESTING.
550 * And when computing --ancestry-path "A..B", the A-X connection is more
551 * important than Y-X, despite both A and Y being flagged UNINTERESTING.
553 static inline int relevant_commit(struct commit *commit)
555 return (commit->object.flags & (UNINTERESTING | BOTTOM)) != UNINTERESTING;
559 * Return a single relevant commit from a parent list. If we are a TREESAME
560 * commit, and this selects one of our parents, then we can safely simplify to
561 * that parent.
563 static struct commit *one_relevant_parent(const struct rev_info *revs,
564 struct commit_list *orig)
566 struct commit_list *list = orig;
567 struct commit *relevant = NULL;
569 if (!orig)
570 return NULL;
573 * For 1-parent commits, or if first-parent-only, then return that
574 * first parent (even if not "relevant" by the above definition).
575 * TREESAME will have been set purely on that parent.
577 if (revs->first_parent_only || !orig->next)
578 return orig->item;
581 * For multi-parent commits, identify a sole relevant parent, if any.
582 * If we have only one relevant parent, then TREESAME will be set purely
583 * with regard to that parent, and we can simplify accordingly.
585 * If we have more than one relevant parent, or no relevant parents
586 * (and multiple irrelevant ones), then we can't select a parent here
587 * and return NULL.
589 while (list) {
590 struct commit *commit = list->item;
591 list = list->next;
592 if (relevant_commit(commit)) {
593 if (relevant)
594 return NULL;
595 relevant = commit;
598 return relevant;
602 * The goal is to get REV_TREE_NEW as the result only if the
603 * diff consists of all '+' (and no other changes), REV_TREE_OLD
604 * if the whole diff is removal of old data, and otherwise
605 * REV_TREE_DIFFERENT (of course if the trees are the same we
606 * want REV_TREE_SAME).
608 * The only time we care about the distinction is when
609 * remove_empty_trees is in effect, in which case we care only about
610 * whether the whole change is REV_TREE_NEW, or if there's another type
611 * of change. Which means we can stop the diff early in either of these
612 * cases:
614 * 1. We're not using remove_empty_trees at all.
616 * 2. We saw anything except REV_TREE_NEW.
618 #define REV_TREE_SAME 0
619 #define REV_TREE_NEW 1 /* Only new files */
620 #define REV_TREE_OLD 2 /* Only files removed */
621 #define REV_TREE_DIFFERENT 3 /* Mixed changes */
622 static int tree_difference = REV_TREE_SAME;
624 static void file_add_remove(struct diff_options *options,
625 int addremove,
626 unsigned mode UNUSED,
627 const struct object_id *oid UNUSED,
628 int oid_valid UNUSED,
629 const char *fullpath UNUSED,
630 unsigned dirty_submodule UNUSED)
632 int diff = addremove == '+' ? REV_TREE_NEW : REV_TREE_OLD;
633 struct rev_info *revs = options->change_fn_data;
635 tree_difference |= diff;
636 if (!revs->remove_empty_trees || tree_difference != REV_TREE_NEW)
637 options->flags.has_changes = 1;
640 static void file_change(struct diff_options *options,
641 unsigned old_mode UNUSED,
642 unsigned new_mode UNUSED,
643 const struct object_id *old_oid UNUSED,
644 const struct object_id *new_oid UNUSED,
645 int old_oid_valid UNUSED,
646 int new_oid_valid UNUSED,
647 const char *fullpath UNUSED,
648 unsigned old_dirty_submodule UNUSED,
649 unsigned new_dirty_submodule UNUSED)
651 tree_difference = REV_TREE_DIFFERENT;
652 options->flags.has_changes = 1;
655 static int bloom_filter_atexit_registered;
656 static unsigned int count_bloom_filter_maybe;
657 static unsigned int count_bloom_filter_definitely_not;
658 static unsigned int count_bloom_filter_false_positive;
659 static unsigned int count_bloom_filter_not_present;
661 static void trace2_bloom_filter_statistics_atexit(void)
663 struct json_writer jw = JSON_WRITER_INIT;
665 jw_object_begin(&jw, 0);
666 jw_object_intmax(&jw, "filter_not_present", count_bloom_filter_not_present);
667 jw_object_intmax(&jw, "maybe", count_bloom_filter_maybe);
668 jw_object_intmax(&jw, "definitely_not", count_bloom_filter_definitely_not);
669 jw_object_intmax(&jw, "false_positive", count_bloom_filter_false_positive);
670 jw_end(&jw);
672 trace2_data_json("bloom", the_repository, "statistics", &jw);
674 jw_release(&jw);
677 static int forbid_bloom_filters(struct pathspec *spec)
679 if (spec->has_wildcard)
680 return 1;
681 if (spec->nr > 1)
682 return 1;
683 if (spec->magic & ~PATHSPEC_LITERAL)
684 return 1;
685 if (spec->nr && (spec->items[0].magic & ~PATHSPEC_LITERAL))
686 return 1;
688 return 0;
691 static void prepare_to_use_bloom_filter(struct rev_info *revs)
693 struct pathspec_item *pi;
694 char *path_alloc = NULL;
695 const char *path, *p;
696 size_t len;
697 int path_component_nr = 1;
699 if (!revs->commits)
700 return;
702 if (forbid_bloom_filters(&revs->prune_data))
703 return;
705 repo_parse_commit(revs->repo, revs->commits->item);
707 revs->bloom_filter_settings = get_bloom_filter_settings(revs->repo);
708 if (!revs->bloom_filter_settings)
709 return;
711 if (!revs->pruning.pathspec.nr)
712 return;
714 pi = &revs->pruning.pathspec.items[0];
716 /* remove single trailing slash from path, if needed */
717 if (pi->len > 0 && pi->match[pi->len - 1] == '/') {
718 path_alloc = xmemdupz(pi->match, pi->len - 1);
719 path = path_alloc;
720 } else
721 path = pi->match;
723 len = strlen(path);
724 if (!len) {
725 revs->bloom_filter_settings = NULL;
726 free(path_alloc);
727 return;
730 p = path;
731 while (*p) {
733 * At this point, the path is normalized to use Unix-style
734 * path separators. This is required due to how the
735 * changed-path Bloom filters store the paths.
737 if (*p == '/')
738 path_component_nr++;
739 p++;
742 revs->bloom_keys_nr = path_component_nr;
743 ALLOC_ARRAY(revs->bloom_keys, revs->bloom_keys_nr);
745 fill_bloom_key(path, len, &revs->bloom_keys[0],
746 revs->bloom_filter_settings);
747 path_component_nr = 1;
749 p = path + len - 1;
750 while (p > path) {
751 if (*p == '/')
752 fill_bloom_key(path, p - path,
753 &revs->bloom_keys[path_component_nr++],
754 revs->bloom_filter_settings);
755 p--;
758 if (trace2_is_enabled() && !bloom_filter_atexit_registered) {
759 atexit(trace2_bloom_filter_statistics_atexit);
760 bloom_filter_atexit_registered = 1;
763 free(path_alloc);
766 static int check_maybe_different_in_bloom_filter(struct rev_info *revs,
767 struct commit *commit)
769 struct bloom_filter *filter;
770 int result = 1, j;
772 if (!revs->repo->objects->commit_graph)
773 return -1;
775 if (commit_graph_generation(commit) == GENERATION_NUMBER_INFINITY)
776 return -1;
778 filter = get_bloom_filter(revs->repo, commit);
780 if (!filter) {
781 count_bloom_filter_not_present++;
782 return -1;
785 for (j = 0; result && j < revs->bloom_keys_nr; j++) {
786 result = bloom_filter_contains(filter,
787 &revs->bloom_keys[j],
788 revs->bloom_filter_settings);
791 if (result)
792 count_bloom_filter_maybe++;
793 else
794 count_bloom_filter_definitely_not++;
796 return result;
799 static int rev_compare_tree(struct rev_info *revs,
800 struct commit *parent, struct commit *commit, int nth_parent)
802 struct tree *t1 = repo_get_commit_tree(the_repository, parent);
803 struct tree *t2 = repo_get_commit_tree(the_repository, commit);
804 int bloom_ret = 1;
806 if (!t1)
807 return REV_TREE_NEW;
808 if (!t2)
809 return REV_TREE_OLD;
811 if (revs->simplify_by_decoration) {
813 * If we are simplifying by decoration, then the commit
814 * is worth showing if it has a tag pointing at it.
816 if (get_name_decoration(&commit->object))
817 return REV_TREE_DIFFERENT;
819 * A commit that is not pointed by a tag is uninteresting
820 * if we are not limited by path. This means that you will
821 * see the usual "commits that touch the paths" plus any
822 * tagged commit by specifying both --simplify-by-decoration
823 * and pathspec.
825 if (!revs->prune_data.nr)
826 return REV_TREE_SAME;
829 if (revs->bloom_keys_nr && !nth_parent) {
830 bloom_ret = check_maybe_different_in_bloom_filter(revs, commit);
832 if (bloom_ret == 0)
833 return REV_TREE_SAME;
836 tree_difference = REV_TREE_SAME;
837 revs->pruning.flags.has_changes = 0;
838 diff_tree_oid(&t1->object.oid, &t2->object.oid, "", &revs->pruning);
840 if (!nth_parent)
841 if (bloom_ret == 1 && tree_difference == REV_TREE_SAME)
842 count_bloom_filter_false_positive++;
844 return tree_difference;
847 static int rev_same_tree_as_empty(struct rev_info *revs, struct commit *commit)
849 struct tree *t1 = repo_get_commit_tree(the_repository, commit);
851 if (!t1)
852 return 0;
854 tree_difference = REV_TREE_SAME;
855 revs->pruning.flags.has_changes = 0;
856 diff_tree_oid(NULL, &t1->object.oid, "", &revs->pruning);
858 return tree_difference == REV_TREE_SAME;
861 struct treesame_state {
862 unsigned int nparents;
863 unsigned char treesame[FLEX_ARRAY];
866 static struct treesame_state *initialise_treesame(struct rev_info *revs, struct commit *commit)
868 unsigned n = commit_list_count(commit->parents);
869 struct treesame_state *st = xcalloc(1, st_add(sizeof(*st), n));
870 st->nparents = n;
871 add_decoration(&revs->treesame, &commit->object, st);
872 return st;
876 * Must be called immediately after removing the nth_parent from a commit's
877 * parent list, if we are maintaining the per-parent treesame[] decoration.
878 * This does not recalculate the master TREESAME flag - update_treesame()
879 * should be called to update it after a sequence of treesame[] modifications
880 * that may have affected it.
882 static int compact_treesame(struct rev_info *revs, struct commit *commit, unsigned nth_parent)
884 struct treesame_state *st;
885 int old_same;
887 if (!commit->parents) {
889 * Have just removed the only parent from a non-merge.
890 * Different handling, as we lack decoration.
892 if (nth_parent != 0)
893 die("compact_treesame %u", nth_parent);
894 old_same = !!(commit->object.flags & TREESAME);
895 if (rev_same_tree_as_empty(revs, commit))
896 commit->object.flags |= TREESAME;
897 else
898 commit->object.flags &= ~TREESAME;
899 return old_same;
902 st = lookup_decoration(&revs->treesame, &commit->object);
903 if (!st || nth_parent >= st->nparents)
904 die("compact_treesame %u", nth_parent);
906 old_same = st->treesame[nth_parent];
907 memmove(st->treesame + nth_parent,
908 st->treesame + nth_parent + 1,
909 st->nparents - nth_parent - 1);
912 * If we've just become a non-merge commit, update TREESAME
913 * immediately, and remove the no-longer-needed decoration.
914 * If still a merge, defer update until update_treesame().
916 if (--st->nparents == 1) {
917 if (commit->parents->next)
918 die("compact_treesame parents mismatch");
919 if (st->treesame[0] && revs->dense)
920 commit->object.flags |= TREESAME;
921 else
922 commit->object.flags &= ~TREESAME;
923 free(add_decoration(&revs->treesame, &commit->object, NULL));
926 return old_same;
929 static unsigned update_treesame(struct rev_info *revs, struct commit *commit)
931 if (commit->parents && commit->parents->next) {
932 unsigned n;
933 struct treesame_state *st;
934 struct commit_list *p;
935 unsigned relevant_parents;
936 unsigned relevant_change, irrelevant_change;
938 st = lookup_decoration(&revs->treesame, &commit->object);
939 if (!st)
940 die("update_treesame %s", oid_to_hex(&commit->object.oid));
941 relevant_parents = 0;
942 relevant_change = irrelevant_change = 0;
943 for (p = commit->parents, n = 0; p; n++, p = p->next) {
944 if (relevant_commit(p->item)) {
945 relevant_change |= !st->treesame[n];
946 relevant_parents++;
947 } else
948 irrelevant_change |= !st->treesame[n];
950 if (relevant_parents ? relevant_change : irrelevant_change)
951 commit->object.flags &= ~TREESAME;
952 else
953 commit->object.flags |= TREESAME;
956 return commit->object.flags & TREESAME;
959 static inline int limiting_can_increase_treesame(const struct rev_info *revs)
962 * TREESAME is irrelevant unless prune && dense;
963 * if simplify_history is set, we can't have a mixture of TREESAME and
964 * !TREESAME INTERESTING parents (and we don't have treesame[]
965 * decoration anyway);
966 * if first_parent_only is set, then the TREESAME flag is locked
967 * against the first parent (and again we lack treesame[] decoration).
969 return revs->prune && revs->dense &&
970 !revs->simplify_history &&
971 !revs->first_parent_only;
974 static void try_to_simplify_commit(struct rev_info *revs, struct commit *commit)
976 struct commit_list **pp, *parent;
977 struct treesame_state *ts = NULL;
978 int relevant_change = 0, irrelevant_change = 0;
979 int relevant_parents, nth_parent;
982 * If we don't do pruning, everything is interesting
984 if (!revs->prune)
985 return;
987 if (!repo_get_commit_tree(the_repository, commit))
988 return;
990 if (!commit->parents) {
991 if (rev_same_tree_as_empty(revs, commit))
992 commit->object.flags |= TREESAME;
993 return;
997 * Normal non-merge commit? If we don't want to make the
998 * history dense, we consider it always to be a change..
1000 if (!revs->dense && !commit->parents->next)
1001 return;
1003 for (pp = &commit->parents, nth_parent = 0, relevant_parents = 0;
1004 (parent = *pp) != NULL;
1005 pp = &parent->next, nth_parent++) {
1006 struct commit *p = parent->item;
1007 if (relevant_commit(p))
1008 relevant_parents++;
1010 if (nth_parent == 1) {
1012 * This our second loop iteration - so we now know
1013 * we're dealing with a merge.
1015 * Do not compare with later parents when we care only about
1016 * the first parent chain, in order to avoid derailing the
1017 * traversal to follow a side branch that brought everything
1018 * in the path we are limited to by the pathspec.
1020 if (revs->first_parent_only)
1021 break;
1023 * If this will remain a potentially-simplifiable
1024 * merge, remember per-parent treesame if needed.
1025 * Initialise the array with the comparison from our
1026 * first iteration.
1028 if (revs->treesame.name &&
1029 !revs->simplify_history &&
1030 !(commit->object.flags & UNINTERESTING)) {
1031 ts = initialise_treesame(revs, commit);
1032 if (!(irrelevant_change || relevant_change))
1033 ts->treesame[0] = 1;
1036 if (repo_parse_commit(revs->repo, p) < 0)
1037 die("cannot simplify commit %s (because of %s)",
1038 oid_to_hex(&commit->object.oid),
1039 oid_to_hex(&p->object.oid));
1040 switch (rev_compare_tree(revs, p, commit, nth_parent)) {
1041 case REV_TREE_SAME:
1042 if (!revs->simplify_history || !relevant_commit(p)) {
1043 /* Even if a merge with an uninteresting
1044 * side branch brought the entire change
1045 * we are interested in, we do not want
1046 * to lose the other branches of this
1047 * merge, so we just keep going.
1049 if (ts)
1050 ts->treesame[nth_parent] = 1;
1051 continue;
1053 parent->next = NULL;
1054 commit->parents = parent;
1057 * A merge commit is a "diversion" if it is not
1058 * TREESAME to its first parent but is TREESAME
1059 * to a later parent. In the simplified history,
1060 * we "divert" the history walk to the later
1061 * parent. These commits are shown when "show_pulls"
1062 * is enabled, so do not mark the object as
1063 * TREESAME here.
1065 if (!revs->show_pulls || !nth_parent)
1066 commit->object.flags |= TREESAME;
1068 return;
1070 case REV_TREE_NEW:
1071 if (revs->remove_empty_trees &&
1072 rev_same_tree_as_empty(revs, p)) {
1073 /* We are adding all the specified
1074 * paths from this parent, so the
1075 * history beyond this parent is not
1076 * interesting. Remove its parents
1077 * (they are grandparents for us).
1078 * IOW, we pretend this parent is a
1079 * "root" commit.
1081 if (repo_parse_commit(revs->repo, p) < 0)
1082 die("cannot simplify commit %s (invalid %s)",
1083 oid_to_hex(&commit->object.oid),
1084 oid_to_hex(&p->object.oid));
1085 p->parents = NULL;
1087 /* fallthrough */
1088 case REV_TREE_OLD:
1089 case REV_TREE_DIFFERENT:
1090 if (relevant_commit(p))
1091 relevant_change = 1;
1092 else
1093 irrelevant_change = 1;
1095 if (!nth_parent)
1096 commit->object.flags |= PULL_MERGE;
1098 continue;
1100 die("bad tree compare for commit %s", oid_to_hex(&commit->object.oid));
1104 * TREESAME is straightforward for single-parent commits. For merge
1105 * commits, it is most useful to define it so that "irrelevant"
1106 * parents cannot make us !TREESAME - if we have any relevant
1107 * parents, then we only consider TREESAMEness with respect to them,
1108 * allowing irrelevant merges from uninteresting branches to be
1109 * simplified away. Only if we have only irrelevant parents do we
1110 * base TREESAME on them. Note that this logic is replicated in
1111 * update_treesame, which should be kept in sync.
1113 if (relevant_parents ? !relevant_change : !irrelevant_change)
1114 commit->object.flags |= TREESAME;
1117 static int process_parents(struct rev_info *revs, struct commit *commit,
1118 struct commit_list **list, struct prio_queue *queue)
1120 struct commit_list *parent = commit->parents;
1121 unsigned pass_flags;
1123 if (commit->object.flags & ADDED)
1124 return 0;
1125 if (revs->do_not_die_on_missing_objects &&
1126 oidset_contains(&revs->missing_commits, &commit->object.oid))
1127 return 0;
1128 commit->object.flags |= ADDED;
1130 if (revs->include_check &&
1131 !revs->include_check(commit, revs->include_check_data))
1132 return 0;
1135 * If the commit is uninteresting, don't try to
1136 * prune parents - we want the maximal uninteresting
1137 * set.
1139 * Normally we haven't parsed the parent
1140 * yet, so we won't have a parent of a parent
1141 * here. However, it may turn out that we've
1142 * reached this commit some other way (where it
1143 * wasn't uninteresting), in which case we need
1144 * to mark its parents recursively too..
1146 if (commit->object.flags & UNINTERESTING) {
1147 while (parent) {
1148 struct commit *p = parent->item;
1149 parent = parent->next;
1150 if (p)
1151 p->object.flags |= UNINTERESTING;
1152 if (repo_parse_commit_gently(revs->repo, p, 1) < 0)
1153 continue;
1154 if (p->parents)
1155 mark_parents_uninteresting(revs, p);
1156 if (p->object.flags & SEEN)
1157 continue;
1158 p->object.flags |= (SEEN | NOT_USER_GIVEN);
1159 if (list)
1160 commit_list_insert_by_date(p, list);
1161 if (queue)
1162 prio_queue_put(queue, p);
1163 if (revs->exclude_first_parent_only)
1164 break;
1166 return 0;
1170 * Ok, the commit wasn't uninteresting. Try to
1171 * simplify the commit history and find the parent
1172 * that has no differences in the path set if one exists.
1174 try_to_simplify_commit(revs, commit);
1176 if (revs->no_walk)
1177 return 0;
1179 pass_flags = (commit->object.flags & (SYMMETRIC_LEFT | ANCESTRY_PATH));
1181 for (parent = commit->parents; parent; parent = parent->next) {
1182 struct commit *p = parent->item;
1183 int gently = revs->ignore_missing_links ||
1184 revs->exclude_promisor_objects ||
1185 revs->do_not_die_on_missing_objects;
1186 if (repo_parse_commit_gently(revs->repo, p, gently) < 0) {
1187 if (revs->exclude_promisor_objects &&
1188 is_promisor_object(&p->object.oid)) {
1189 if (revs->first_parent_only)
1190 break;
1191 continue;
1194 if (revs->do_not_die_on_missing_objects)
1195 oidset_insert(&revs->missing_commits, &p->object.oid);
1196 else
1197 return -1; /* corrupt repository */
1199 if (revs->sources) {
1200 char **slot = revision_sources_at(revs->sources, p);
1202 if (!*slot)
1203 *slot = *revision_sources_at(revs->sources, commit);
1205 p->object.flags |= pass_flags;
1206 if (!(p->object.flags & SEEN)) {
1207 p->object.flags |= (SEEN | NOT_USER_GIVEN);
1208 if (list)
1209 commit_list_insert_by_date(p, list);
1210 if (queue)
1211 prio_queue_put(queue, p);
1213 if (revs->first_parent_only)
1214 break;
1216 return 0;
1219 static void cherry_pick_list(struct commit_list *list, struct rev_info *revs)
1221 struct commit_list *p;
1222 int left_count = 0, right_count = 0;
1223 int left_first;
1224 struct patch_ids ids;
1225 unsigned cherry_flag;
1227 /* First count the commits on the left and on the right */
1228 for (p = list; p; p = p->next) {
1229 struct commit *commit = p->item;
1230 unsigned flags = commit->object.flags;
1231 if (flags & BOUNDARY)
1233 else if (flags & SYMMETRIC_LEFT)
1234 left_count++;
1235 else
1236 right_count++;
1239 if (!left_count || !right_count)
1240 return;
1242 left_first = left_count < right_count;
1243 init_patch_ids(revs->repo, &ids);
1244 ids.diffopts.pathspec = revs->diffopt.pathspec;
1246 /* Compute patch-ids for one side */
1247 for (p = list; p; p = p->next) {
1248 struct commit *commit = p->item;
1249 unsigned flags = commit->object.flags;
1251 if (flags & BOUNDARY)
1252 continue;
1254 * If we have fewer left, left_first is set and we omit
1255 * commits on the right branch in this loop. If we have
1256 * fewer right, we skip the left ones.
1258 if (left_first != !!(flags & SYMMETRIC_LEFT))
1259 continue;
1260 add_commit_patch_id(commit, &ids);
1263 /* either cherry_mark or cherry_pick are true */
1264 cherry_flag = revs->cherry_mark ? PATCHSAME : SHOWN;
1266 /* Check the other side */
1267 for (p = list; p; p = p->next) {
1268 struct commit *commit = p->item;
1269 struct patch_id *id;
1270 unsigned flags = commit->object.flags;
1272 if (flags & BOUNDARY)
1273 continue;
1275 * If we have fewer left, left_first is set and we omit
1276 * commits on the left branch in this loop.
1278 if (left_first == !!(flags & SYMMETRIC_LEFT))
1279 continue;
1282 * Have we seen the same patch id?
1284 id = patch_id_iter_first(commit, &ids);
1285 if (!id)
1286 continue;
1288 commit->object.flags |= cherry_flag;
1289 do {
1290 id->commit->object.flags |= cherry_flag;
1291 } while ((id = patch_id_iter_next(id, &ids)));
1294 free_patch_ids(&ids);
1297 /* How many extra uninteresting commits we want to see.. */
1298 #define SLOP 5
1300 static int still_interesting(struct commit_list *src, timestamp_t date, int slop,
1301 struct commit **interesting_cache)
1304 * No source list at all? We're definitely done..
1306 if (!src)
1307 return 0;
1310 * Does the destination list contain entries with a date
1311 * before the source list? Definitely _not_ done.
1313 if (date <= src->item->date)
1314 return SLOP;
1317 * Does the source list still have interesting commits in
1318 * it? Definitely not done..
1320 if (!everybody_uninteresting(src, interesting_cache))
1321 return SLOP;
1323 /* Ok, we're closing in.. */
1324 return slop-1;
1328 * "rev-list --ancestry-path=C_0 [--ancestry-path=C_1 ...] A..B"
1329 * computes commits that are ancestors of B but not ancestors of A but
1330 * further limits the result to those that have any of C in their
1331 * ancestry path (i.e. are either ancestors of any of C, descendants
1332 * of any of C, or are any of C). If --ancestry-path is specified with
1333 * no commit, we use all bottom commits for C.
1335 * Before this function is called, ancestors of C will have already
1336 * been marked with ANCESTRY_PATH previously.
1338 * This takes the list of bottom commits and the result of "A..B"
1339 * without --ancestry-path, and limits the latter further to the ones
1340 * that have any of C in their ancestry path. Since the ancestors of C
1341 * have already been marked (a prerequisite of this function), we just
1342 * need to mark the descendants, then exclude any commit that does not
1343 * have any of these marks.
1345 static void limit_to_ancestry(struct commit_list *bottoms, struct commit_list *list)
1347 struct commit_list *p;
1348 struct commit_list *rlist = NULL;
1349 int made_progress;
1352 * Reverse the list so that it will be likely that we would
1353 * process parents before children.
1355 for (p = list; p; p = p->next)
1356 commit_list_insert(p->item, &rlist);
1358 for (p = bottoms; p; p = p->next)
1359 p->item->object.flags |= TMP_MARK;
1362 * Mark the ones that can reach bottom commits in "list",
1363 * in a bottom-up fashion.
1365 do {
1366 made_progress = 0;
1367 for (p = rlist; p; p = p->next) {
1368 struct commit *c = p->item;
1369 struct commit_list *parents;
1370 if (c->object.flags & (TMP_MARK | UNINTERESTING))
1371 continue;
1372 for (parents = c->parents;
1373 parents;
1374 parents = parents->next) {
1375 if (!(parents->item->object.flags & TMP_MARK))
1376 continue;
1377 c->object.flags |= TMP_MARK;
1378 made_progress = 1;
1379 break;
1382 } while (made_progress);
1385 * NEEDSWORK: decide if we want to remove parents that are
1386 * not marked with TMP_MARK from commit->parents for commits
1387 * in the resulting list. We may not want to do that, though.
1391 * The ones that are not marked with either TMP_MARK or
1392 * ANCESTRY_PATH are uninteresting
1394 for (p = list; p; p = p->next) {
1395 struct commit *c = p->item;
1396 if (c->object.flags & (TMP_MARK | ANCESTRY_PATH))
1397 continue;
1398 c->object.flags |= UNINTERESTING;
1401 /* We are done with TMP_MARK and ANCESTRY_PATH */
1402 for (p = list; p; p = p->next)
1403 p->item->object.flags &= ~(TMP_MARK | ANCESTRY_PATH);
1404 for (p = bottoms; p; p = p->next)
1405 p->item->object.flags &= ~(TMP_MARK | ANCESTRY_PATH);
1406 free_commit_list(rlist);
1410 * Before walking the history, add the set of "negative" refs the
1411 * caller has asked to exclude to the bottom list.
1413 * This is used to compute "rev-list --ancestry-path A..B", as we need
1414 * to filter the result of "A..B" further to the ones that can actually
1415 * reach A.
1417 static void collect_bottom_commits(struct commit_list *list,
1418 struct commit_list **bottom)
1420 struct commit_list *elem;
1421 for (elem = list; elem; elem = elem->next)
1422 if (elem->item->object.flags & BOTTOM)
1423 commit_list_insert(elem->item, bottom);
1426 /* Assumes either left_only or right_only is set */
1427 static void limit_left_right(struct commit_list *list, struct rev_info *revs)
1429 struct commit_list *p;
1431 for (p = list; p; p = p->next) {
1432 struct commit *commit = p->item;
1434 if (revs->right_only) {
1435 if (commit->object.flags & SYMMETRIC_LEFT)
1436 commit->object.flags |= SHOWN;
1437 } else /* revs->left_only is set */
1438 if (!(commit->object.flags & SYMMETRIC_LEFT))
1439 commit->object.flags |= SHOWN;
1443 static int limit_list(struct rev_info *revs)
1445 int slop = SLOP;
1446 timestamp_t date = TIME_MAX;
1447 struct commit_list *original_list = revs->commits;
1448 struct commit_list *newlist = NULL;
1449 struct commit_list **p = &newlist;
1450 struct commit *interesting_cache = NULL;
1452 if (revs->ancestry_path_implicit_bottoms) {
1453 collect_bottom_commits(original_list,
1454 &revs->ancestry_path_bottoms);
1455 if (!revs->ancestry_path_bottoms)
1456 die("--ancestry-path given but there are no bottom commits");
1459 while (original_list) {
1460 struct commit *commit = pop_commit(&original_list);
1461 struct object *obj = &commit->object;
1462 show_early_output_fn_t show;
1464 if (commit == interesting_cache)
1465 interesting_cache = NULL;
1467 if (revs->max_age != -1 && (commit->date < revs->max_age))
1468 obj->flags |= UNINTERESTING;
1469 if (process_parents(revs, commit, &original_list, NULL) < 0)
1470 return -1;
1471 if (obj->flags & UNINTERESTING) {
1472 mark_parents_uninteresting(revs, commit);
1473 slop = still_interesting(original_list, date, slop, &interesting_cache);
1474 if (slop)
1475 continue;
1476 break;
1478 if (revs->min_age != -1 && (commit->date > revs->min_age) &&
1479 !revs->line_level_traverse)
1480 continue;
1481 if (revs->max_age_as_filter != -1 &&
1482 (commit->date < revs->max_age_as_filter) && !revs->line_level_traverse)
1483 continue;
1484 date = commit->date;
1485 p = &commit_list_insert(commit, p)->next;
1487 show = show_early_output;
1488 if (!show)
1489 continue;
1491 show(revs, newlist);
1492 show_early_output = NULL;
1494 if (revs->cherry_pick || revs->cherry_mark)
1495 cherry_pick_list(newlist, revs);
1497 if (revs->left_only || revs->right_only)
1498 limit_left_right(newlist, revs);
1500 if (revs->ancestry_path)
1501 limit_to_ancestry(revs->ancestry_path_bottoms, newlist);
1504 * Check if any commits have become TREESAME by some of their parents
1505 * becoming UNINTERESTING.
1507 if (limiting_can_increase_treesame(revs)) {
1508 struct commit_list *list = NULL;
1509 for (list = newlist; list; list = list->next) {
1510 struct commit *c = list->item;
1511 if (c->object.flags & (UNINTERESTING | TREESAME))
1512 continue;
1513 update_treesame(revs, c);
1517 free_commit_list(original_list);
1518 revs->commits = newlist;
1519 return 0;
1523 * Add an entry to refs->cmdline with the specified information.
1524 * *name is copied.
1526 static void add_rev_cmdline(struct rev_info *revs,
1527 struct object *item,
1528 const char *name,
1529 int whence,
1530 unsigned flags)
1532 struct rev_cmdline_info *info = &revs->cmdline;
1533 unsigned int nr = info->nr;
1535 ALLOC_GROW(info->rev, nr + 1, info->alloc);
1536 info->rev[nr].item = item;
1537 info->rev[nr].name = xstrdup(name);
1538 info->rev[nr].whence = whence;
1539 info->rev[nr].flags = flags;
1540 info->nr++;
1543 static void add_rev_cmdline_list(struct rev_info *revs,
1544 struct commit_list *commit_list,
1545 int whence,
1546 unsigned flags)
1548 while (commit_list) {
1549 struct object *object = &commit_list->item->object;
1550 add_rev_cmdline(revs, object, oid_to_hex(&object->oid),
1551 whence, flags);
1552 commit_list = commit_list->next;
1556 int ref_excluded(const struct ref_exclusions *exclusions, const char *path)
1558 const char *stripped_path = strip_namespace(path);
1559 struct string_list_item *item;
1561 for_each_string_list_item(item, &exclusions->excluded_refs) {
1562 if (!wildmatch(item->string, path, 0))
1563 return 1;
1566 if (ref_is_hidden(stripped_path, path, &exclusions->hidden_refs))
1567 return 1;
1569 return 0;
1572 void init_ref_exclusions(struct ref_exclusions *exclusions)
1574 struct ref_exclusions blank = REF_EXCLUSIONS_INIT;
1575 memcpy(exclusions, &blank, sizeof(*exclusions));
1578 void clear_ref_exclusions(struct ref_exclusions *exclusions)
1580 string_list_clear(&exclusions->excluded_refs, 0);
1581 strvec_clear(&exclusions->hidden_refs);
1582 exclusions->hidden_refs_configured = 0;
1585 void add_ref_exclusion(struct ref_exclusions *exclusions, const char *exclude)
1587 string_list_append(&exclusions->excluded_refs, exclude);
1590 struct exclude_hidden_refs_cb {
1591 struct ref_exclusions *exclusions;
1592 const char *section;
1595 static int hide_refs_config(const char *var, const char *value,
1596 const struct config_context *ctx UNUSED,
1597 void *cb_data)
1599 struct exclude_hidden_refs_cb *cb = cb_data;
1600 cb->exclusions->hidden_refs_configured = 1;
1601 return parse_hide_refs_config(var, value, cb->section,
1602 &cb->exclusions->hidden_refs);
1605 void exclude_hidden_refs(struct ref_exclusions *exclusions, const char *section)
1607 struct exclude_hidden_refs_cb cb;
1609 if (strcmp(section, "fetch") && strcmp(section, "receive") &&
1610 strcmp(section, "uploadpack"))
1611 die(_("unsupported section for hidden refs: %s"), section);
1613 if (exclusions->hidden_refs_configured)
1614 die(_("--exclude-hidden= passed more than once"));
1616 cb.exclusions = exclusions;
1617 cb.section = section;
1619 git_config(hide_refs_config, &cb);
1622 struct all_refs_cb {
1623 int all_flags;
1624 int warned_bad_reflog;
1625 struct rev_info *all_revs;
1626 const char *name_for_errormsg;
1627 struct worktree *wt;
1630 static int handle_one_ref(const char *path, const struct object_id *oid,
1631 int flag UNUSED,
1632 void *cb_data)
1634 struct all_refs_cb *cb = cb_data;
1635 struct object *object;
1637 if (ref_excluded(&cb->all_revs->ref_excludes, path))
1638 return 0;
1640 object = get_reference(cb->all_revs, path, oid, cb->all_flags);
1641 add_rev_cmdline(cb->all_revs, object, path, REV_CMD_REF, cb->all_flags);
1642 add_pending_object(cb->all_revs, object, path);
1643 return 0;
1646 static void init_all_refs_cb(struct all_refs_cb *cb, struct rev_info *revs,
1647 unsigned flags)
1649 cb->all_revs = revs;
1650 cb->all_flags = flags;
1651 revs->rev_input_given = 1;
1652 cb->wt = NULL;
1655 static void handle_refs(struct ref_store *refs,
1656 struct rev_info *revs, unsigned flags,
1657 int (*for_each)(struct ref_store *, each_ref_fn, void *))
1659 struct all_refs_cb cb;
1661 if (!refs) {
1662 /* this could happen with uninitialized submodules */
1663 return;
1666 init_all_refs_cb(&cb, revs, flags);
1667 for_each(refs, handle_one_ref, &cb);
1670 static void handle_one_reflog_commit(struct object_id *oid, void *cb_data)
1672 struct all_refs_cb *cb = cb_data;
1673 if (!is_null_oid(oid)) {
1674 struct object *o = parse_object(cb->all_revs->repo, oid);
1675 if (o) {
1676 o->flags |= cb->all_flags;
1677 /* ??? CMDLINEFLAGS ??? */
1678 add_pending_object(cb->all_revs, o, "");
1680 else if (!cb->warned_bad_reflog) {
1681 warning("reflog of '%s' references pruned commits",
1682 cb->name_for_errormsg);
1683 cb->warned_bad_reflog = 1;
1688 static int handle_one_reflog_ent(struct object_id *ooid, struct object_id *noid,
1689 const char *email UNUSED,
1690 timestamp_t timestamp UNUSED,
1691 int tz UNUSED,
1692 const char *message UNUSED,
1693 void *cb_data)
1695 handle_one_reflog_commit(ooid, cb_data);
1696 handle_one_reflog_commit(noid, cb_data);
1697 return 0;
1700 static int handle_one_reflog(const char *refname_in_wt, void *cb_data)
1702 struct all_refs_cb *cb = cb_data;
1703 struct strbuf refname = STRBUF_INIT;
1705 cb->warned_bad_reflog = 0;
1706 strbuf_worktree_ref(cb->wt, &refname, refname_in_wt);
1707 cb->name_for_errormsg = refname.buf;
1708 refs_for_each_reflog_ent(get_main_ref_store(the_repository),
1709 refname.buf,
1710 handle_one_reflog_ent, cb_data);
1711 strbuf_release(&refname);
1712 return 0;
1715 static void add_other_reflogs_to_pending(struct all_refs_cb *cb)
1717 struct worktree **worktrees, **p;
1719 worktrees = get_worktrees();
1720 for (p = worktrees; *p; p++) {
1721 struct worktree *wt = *p;
1723 if (wt->is_current)
1724 continue;
1726 cb->wt = wt;
1727 refs_for_each_reflog(get_worktree_ref_store(wt),
1728 handle_one_reflog,
1729 cb);
1731 free_worktrees(worktrees);
1734 void add_reflogs_to_pending(struct rev_info *revs, unsigned flags)
1736 struct all_refs_cb cb;
1738 cb.all_revs = revs;
1739 cb.all_flags = flags;
1740 cb.wt = NULL;
1741 for_each_reflog(handle_one_reflog, &cb);
1743 if (!revs->single_worktree)
1744 add_other_reflogs_to_pending(&cb);
1747 static void add_cache_tree(struct cache_tree *it, struct rev_info *revs,
1748 struct strbuf *path, unsigned int flags)
1750 size_t baselen = path->len;
1751 int i;
1753 if (it->entry_count >= 0) {
1754 struct tree *tree = lookup_tree(revs->repo, &it->oid);
1755 tree->object.flags |= flags;
1756 add_pending_object_with_path(revs, &tree->object, "",
1757 040000, path->buf);
1760 for (i = 0; i < it->subtree_nr; i++) {
1761 struct cache_tree_sub *sub = it->down[i];
1762 strbuf_addf(path, "%s%s", baselen ? "/" : "", sub->name);
1763 add_cache_tree(sub->cache_tree, revs, path, flags);
1764 strbuf_setlen(path, baselen);
1769 static void add_resolve_undo_to_pending(struct index_state *istate, struct rev_info *revs)
1771 struct string_list_item *item;
1772 struct string_list *resolve_undo = istate->resolve_undo;
1774 if (!resolve_undo)
1775 return;
1777 for_each_string_list_item(item, resolve_undo) {
1778 const char *path = item->string;
1779 struct resolve_undo_info *ru = item->util;
1780 int i;
1782 if (!ru)
1783 continue;
1784 for (i = 0; i < 3; i++) {
1785 struct blob *blob;
1787 if (!ru->mode[i] || !S_ISREG(ru->mode[i]))
1788 continue;
1790 blob = lookup_blob(revs->repo, &ru->oid[i]);
1791 if (!blob) {
1792 warning(_("resolve-undo records `%s` which is missing"),
1793 oid_to_hex(&ru->oid[i]));
1794 continue;
1796 add_pending_object_with_path(revs, &blob->object, "",
1797 ru->mode[i], path);
1802 static void do_add_index_objects_to_pending(struct rev_info *revs,
1803 struct index_state *istate,
1804 unsigned int flags)
1806 int i;
1808 /* TODO: audit for interaction with sparse-index. */
1809 ensure_full_index(istate);
1810 for (i = 0; i < istate->cache_nr; i++) {
1811 struct cache_entry *ce = istate->cache[i];
1812 struct blob *blob;
1814 if (S_ISGITLINK(ce->ce_mode))
1815 continue;
1817 blob = lookup_blob(revs->repo, &ce->oid);
1818 if (!blob)
1819 die("unable to add index blob to traversal");
1820 blob->object.flags |= flags;
1821 add_pending_object_with_path(revs, &blob->object, "",
1822 ce->ce_mode, ce->name);
1825 if (istate->cache_tree) {
1826 struct strbuf path = STRBUF_INIT;
1827 add_cache_tree(istate->cache_tree, revs, &path, flags);
1828 strbuf_release(&path);
1831 add_resolve_undo_to_pending(istate, revs);
1834 void add_index_objects_to_pending(struct rev_info *revs, unsigned int flags)
1836 struct worktree **worktrees, **p;
1838 repo_read_index(revs->repo);
1839 do_add_index_objects_to_pending(revs, revs->repo->index, flags);
1841 if (revs->single_worktree)
1842 return;
1844 worktrees = get_worktrees();
1845 for (p = worktrees; *p; p++) {
1846 struct worktree *wt = *p;
1847 struct index_state istate = INDEX_STATE_INIT(revs->repo);
1849 if (wt->is_current)
1850 continue; /* current index already taken care of */
1852 if (read_index_from(&istate,
1853 worktree_git_path(wt, "index"),
1854 get_worktree_git_dir(wt)) > 0)
1855 do_add_index_objects_to_pending(revs, &istate, flags);
1856 discard_index(&istate);
1858 free_worktrees(worktrees);
1861 struct add_alternate_refs_data {
1862 struct rev_info *revs;
1863 unsigned int flags;
1866 static void add_one_alternate_ref(const struct object_id *oid,
1867 void *vdata)
1869 const char *name = ".alternate";
1870 struct add_alternate_refs_data *data = vdata;
1871 struct object *obj;
1873 obj = get_reference(data->revs, name, oid, data->flags);
1874 add_rev_cmdline(data->revs, obj, name, REV_CMD_REV, data->flags);
1875 add_pending_object(data->revs, obj, name);
1878 static void add_alternate_refs_to_pending(struct rev_info *revs,
1879 unsigned int flags)
1881 struct add_alternate_refs_data data;
1882 data.revs = revs;
1883 data.flags = flags;
1884 for_each_alternate_ref(add_one_alternate_ref, &data);
1887 static int add_parents_only(struct rev_info *revs, const char *arg_, int flags,
1888 int exclude_parent)
1890 struct object_id oid;
1891 struct object *it;
1892 struct commit *commit;
1893 struct commit_list *parents;
1894 int parent_number;
1895 const char *arg = arg_;
1897 if (*arg == '^') {
1898 flags ^= UNINTERESTING | BOTTOM;
1899 arg++;
1901 if (repo_get_oid_committish(the_repository, arg, &oid))
1902 return 0;
1903 while (1) {
1904 it = get_reference(revs, arg, &oid, 0);
1905 if (!it && revs->ignore_missing)
1906 return 0;
1907 if (it->type != OBJ_TAG)
1908 break;
1909 if (!((struct tag*)it)->tagged)
1910 return 0;
1911 oidcpy(&oid, &((struct tag*)it)->tagged->oid);
1913 if (it->type != OBJ_COMMIT)
1914 return 0;
1915 commit = (struct commit *)it;
1916 if (exclude_parent &&
1917 exclude_parent > commit_list_count(commit->parents))
1918 return 0;
1919 for (parents = commit->parents, parent_number = 1;
1920 parents;
1921 parents = parents->next, parent_number++) {
1922 if (exclude_parent && parent_number != exclude_parent)
1923 continue;
1925 it = &parents->item->object;
1926 it->flags |= flags;
1927 add_rev_cmdline(revs, it, arg_, REV_CMD_PARENTS_ONLY, flags);
1928 add_pending_object(revs, it, arg);
1930 return 1;
1933 void repo_init_revisions(struct repository *r,
1934 struct rev_info *revs,
1935 const char *prefix)
1937 struct rev_info blank = REV_INFO_INIT;
1938 memcpy(revs, &blank, sizeof(*revs));
1940 revs->repo = r;
1941 revs->pruning.repo = r;
1942 revs->pruning.add_remove = file_add_remove;
1943 revs->pruning.change = file_change;
1944 revs->pruning.change_fn_data = revs;
1945 revs->prefix = prefix;
1947 grep_init(&revs->grep_filter, revs->repo);
1948 revs->grep_filter.status_only = 1;
1950 repo_diff_setup(revs->repo, &revs->diffopt);
1951 if (prefix && !revs->diffopt.prefix) {
1952 revs->diffopt.prefix = prefix;
1953 revs->diffopt.prefix_length = strlen(prefix);
1956 init_display_notes(&revs->notes_opt);
1957 list_objects_filter_init(&revs->filter);
1958 init_ref_exclusions(&revs->ref_excludes);
1959 oidset_init(&revs->missing_commits, 0);
1962 static void add_pending_commit_list(struct rev_info *revs,
1963 struct commit_list *commit_list,
1964 unsigned int flags)
1966 while (commit_list) {
1967 struct object *object = &commit_list->item->object;
1968 object->flags |= flags;
1969 add_pending_object(revs, object, oid_to_hex(&object->oid));
1970 commit_list = commit_list->next;
1974 static const char *lookup_other_head(struct object_id *oid)
1976 int i;
1977 static const char *const other_head[] = {
1978 "MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "REBASE_HEAD"
1981 for (i = 0; i < ARRAY_SIZE(other_head); i++)
1982 if (!read_ref_full(other_head[i],
1983 RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE,
1984 oid, NULL)) {
1985 if (is_null_oid(oid))
1986 die(_("%s exists but is a symbolic ref"), other_head[i]);
1987 return other_head[i];
1990 die(_("--merge requires one of the pseudorefs MERGE_HEAD, CHERRY_PICK_HEAD, REVERT_HEAD or REBASE_HEAD"));
1993 static void prepare_show_merge(struct rev_info *revs)
1995 struct commit_list *bases = NULL;
1996 struct commit *head, *other;
1997 struct object_id oid;
1998 const char *other_name;
1999 const char **prune = NULL;
2000 int i, prune_num = 1; /* counting terminating NULL */
2001 struct index_state *istate = revs->repo->index;
2003 if (repo_get_oid(the_repository, "HEAD", &oid))
2004 die("--merge without HEAD?");
2005 head = lookup_commit_or_die(&oid, "HEAD");
2006 other_name = lookup_other_head(&oid);
2007 other = lookup_commit_or_die(&oid, other_name);
2008 add_pending_object(revs, &head->object, "HEAD");
2009 add_pending_object(revs, &other->object, other_name);
2010 if (repo_get_merge_bases(the_repository, head, other, &bases) < 0)
2011 exit(128);
2012 add_rev_cmdline_list(revs, bases, REV_CMD_MERGE_BASE, UNINTERESTING | BOTTOM);
2013 add_pending_commit_list(revs, bases, UNINTERESTING | BOTTOM);
2014 free_commit_list(bases);
2015 head->object.flags |= SYMMETRIC_LEFT;
2017 if (!istate->cache_nr)
2018 repo_read_index(revs->repo);
2019 for (i = 0; i < istate->cache_nr; i++) {
2020 const struct cache_entry *ce = istate->cache[i];
2021 if (!ce_stage(ce))
2022 continue;
2023 if (ce_path_match(istate, ce, &revs->prune_data, NULL)) {
2024 prune_num++;
2025 REALLOC_ARRAY(prune, prune_num);
2026 prune[prune_num-2] = ce->name;
2027 prune[prune_num-1] = NULL;
2029 while ((i+1 < istate->cache_nr) &&
2030 ce_same_name(ce, istate->cache[i+1]))
2031 i++;
2033 clear_pathspec(&revs->prune_data);
2034 parse_pathspec(&revs->prune_data, PATHSPEC_ALL_MAGIC & ~PATHSPEC_LITERAL,
2035 PATHSPEC_PREFER_FULL | PATHSPEC_LITERAL_PATH, "", prune);
2036 revs->limited = 1;
2039 static int dotdot_missing(const char *arg, char *dotdot,
2040 struct rev_info *revs, int symmetric)
2042 if (revs->ignore_missing)
2043 return 0;
2044 /* de-munge so we report the full argument */
2045 *dotdot = '.';
2046 die(symmetric
2047 ? "Invalid symmetric difference expression %s"
2048 : "Invalid revision range %s", arg);
2051 static int handle_dotdot_1(const char *arg, char *dotdot,
2052 struct rev_info *revs, int flags,
2053 int cant_be_filename,
2054 struct object_context *a_oc,
2055 struct object_context *b_oc)
2057 const char *a_name, *b_name;
2058 struct object_id a_oid, b_oid;
2059 struct object *a_obj, *b_obj;
2060 unsigned int a_flags, b_flags;
2061 int symmetric = 0;
2062 unsigned int flags_exclude = flags ^ (UNINTERESTING | BOTTOM);
2063 unsigned int oc_flags = GET_OID_COMMITTISH | GET_OID_RECORD_PATH;
2065 a_name = arg;
2066 if (!*a_name)
2067 a_name = "HEAD";
2069 b_name = dotdot + 2;
2070 if (*b_name == '.') {
2071 symmetric = 1;
2072 b_name++;
2074 if (!*b_name)
2075 b_name = "HEAD";
2077 if (get_oid_with_context(revs->repo, a_name, oc_flags, &a_oid, a_oc) ||
2078 get_oid_with_context(revs->repo, b_name, oc_flags, &b_oid, b_oc))
2079 return -1;
2081 if (!cant_be_filename) {
2082 *dotdot = '.';
2083 verify_non_filename(revs->prefix, arg);
2084 *dotdot = '\0';
2087 a_obj = parse_object(revs->repo, &a_oid);
2088 b_obj = parse_object(revs->repo, &b_oid);
2089 if (!a_obj || !b_obj)
2090 return dotdot_missing(arg, dotdot, revs, symmetric);
2092 if (!symmetric) {
2093 /* just A..B */
2094 b_flags = flags;
2095 a_flags = flags_exclude;
2096 } else {
2097 /* A...B -- find merge bases between the two */
2098 struct commit *a, *b;
2099 struct commit_list *exclude = NULL;
2101 a = lookup_commit_reference(revs->repo, &a_obj->oid);
2102 b = lookup_commit_reference(revs->repo, &b_obj->oid);
2103 if (!a || !b)
2104 return dotdot_missing(arg, dotdot, revs, symmetric);
2106 if (repo_get_merge_bases(the_repository, a, b, &exclude) < 0) {
2107 free_commit_list(exclude);
2108 return -1;
2110 add_rev_cmdline_list(revs, exclude, REV_CMD_MERGE_BASE,
2111 flags_exclude);
2112 add_pending_commit_list(revs, exclude, flags_exclude);
2113 free_commit_list(exclude);
2115 b_flags = flags;
2116 a_flags = flags | SYMMETRIC_LEFT;
2119 a_obj->flags |= a_flags;
2120 b_obj->flags |= b_flags;
2121 add_rev_cmdline(revs, a_obj, a_name, REV_CMD_LEFT, a_flags);
2122 add_rev_cmdline(revs, b_obj, b_name, REV_CMD_RIGHT, b_flags);
2123 add_pending_object_with_path(revs, a_obj, a_name, a_oc->mode, a_oc->path);
2124 add_pending_object_with_path(revs, b_obj, b_name, b_oc->mode, b_oc->path);
2125 return 0;
2128 static int handle_dotdot(const char *arg,
2129 struct rev_info *revs, int flags,
2130 int cant_be_filename)
2132 struct object_context a_oc, b_oc;
2133 char *dotdot = strstr(arg, "..");
2134 int ret;
2136 if (!dotdot)
2137 return -1;
2139 memset(&a_oc, 0, sizeof(a_oc));
2140 memset(&b_oc, 0, sizeof(b_oc));
2142 *dotdot = '\0';
2143 ret = handle_dotdot_1(arg, dotdot, revs, flags, cant_be_filename,
2144 &a_oc, &b_oc);
2145 *dotdot = '.';
2147 free(a_oc.path);
2148 free(b_oc.path);
2150 return ret;
2153 static int handle_revision_arg_1(const char *arg_, struct rev_info *revs, int flags, unsigned revarg_opt)
2155 struct object_context oc;
2156 char *mark;
2157 struct object *object;
2158 struct object_id oid;
2159 int local_flags;
2160 const char *arg = arg_;
2161 int cant_be_filename = revarg_opt & REVARG_CANNOT_BE_FILENAME;
2162 unsigned get_sha1_flags = GET_OID_RECORD_PATH;
2164 flags = flags & UNINTERESTING ? flags | BOTTOM : flags & ~BOTTOM;
2166 if (!cant_be_filename && !strcmp(arg, "..")) {
2168 * Just ".."? That is not a range but the
2169 * pathspec for the parent directory.
2171 return -1;
2174 if (!handle_dotdot(arg, revs, flags, revarg_opt))
2175 return 0;
2177 mark = strstr(arg, "^@");
2178 if (mark && !mark[2]) {
2179 *mark = 0;
2180 if (add_parents_only(revs, arg, flags, 0))
2181 return 0;
2182 *mark = '^';
2184 mark = strstr(arg, "^!");
2185 if (mark && !mark[2]) {
2186 *mark = 0;
2187 if (!add_parents_only(revs, arg, flags ^ (UNINTERESTING | BOTTOM), 0))
2188 *mark = '^';
2190 mark = strstr(arg, "^-");
2191 if (mark) {
2192 int exclude_parent = 1;
2194 if (mark[2]) {
2195 if (strtol_i(mark + 2, 10, &exclude_parent) ||
2196 exclude_parent < 1)
2197 return -1;
2200 *mark = 0;
2201 if (!add_parents_only(revs, arg, flags ^ (UNINTERESTING | BOTTOM), exclude_parent))
2202 *mark = '^';
2205 local_flags = 0;
2206 if (*arg == '^') {
2207 local_flags = UNINTERESTING | BOTTOM;
2208 arg++;
2211 if (revarg_opt & REVARG_COMMITTISH)
2212 get_sha1_flags |= GET_OID_COMMITTISH;
2215 * Even if revs->do_not_die_on_missing_objects is set, we
2216 * should error out if we can't even get an oid, as
2217 * `--missing=print` should be able to report missing oids.
2219 if (get_oid_with_context(revs->repo, arg, get_sha1_flags, &oid, &oc))
2220 return revs->ignore_missing ? 0 : -1;
2221 if (!cant_be_filename)
2222 verify_non_filename(revs->prefix, arg);
2223 object = get_reference(revs, arg, &oid, flags ^ local_flags);
2224 if (!object)
2225 return (revs->ignore_missing || revs->do_not_die_on_missing_objects) ? 0 : -1;
2226 add_rev_cmdline(revs, object, arg_, REV_CMD_REV, flags ^ local_flags);
2227 add_pending_object_with_path(revs, object, arg, oc.mode, oc.path);
2228 free(oc.path);
2229 return 0;
2232 int handle_revision_arg(const char *arg, struct rev_info *revs, int flags, unsigned revarg_opt)
2234 int ret = handle_revision_arg_1(arg, revs, flags, revarg_opt);
2235 if (!ret)
2236 revs->rev_input_given = 1;
2237 return ret;
2240 static void read_pathspec_from_stdin(struct strbuf *sb,
2241 struct strvec *prune)
2243 while (strbuf_getline(sb, stdin) != EOF)
2244 strvec_push(prune, sb->buf);
2247 static void add_grep(struct rev_info *revs, const char *ptn, enum grep_pat_token what)
2249 append_grep_pattern(&revs->grep_filter, ptn, "command line", 0, what);
2252 static void add_header_grep(struct rev_info *revs, enum grep_header_field field, const char *pattern)
2254 append_header_grep_pattern(&revs->grep_filter, field, pattern);
2257 static void add_message_grep(struct rev_info *revs, const char *pattern)
2259 add_grep(revs, pattern, GREP_PATTERN_BODY);
2262 static int parse_count(const char *arg)
2264 int count;
2266 if (strtol_i(arg, 10, &count) < 0)
2267 die("'%s': not an integer", arg);
2268 return count;
2271 static timestamp_t parse_age(const char *arg)
2273 timestamp_t num;
2274 char *p;
2276 errno = 0;
2277 num = parse_timestamp(arg, &p, 10);
2278 if (errno || *p || p == arg)
2279 die("'%s': not a number of seconds since epoch", arg);
2280 return num;
2283 static int handle_revision_opt(struct rev_info *revs, int argc, const char **argv,
2284 int *unkc, const char **unkv,
2285 const struct setup_revision_opt* opt)
2287 const char *arg = argv[0];
2288 const char *optarg = NULL;
2289 int argcount;
2290 const unsigned hexsz = the_hash_algo->hexsz;
2292 /* pseudo revision arguments */
2293 if (!strcmp(arg, "--all") || !strcmp(arg, "--branches") ||
2294 !strcmp(arg, "--tags") || !strcmp(arg, "--remotes") ||
2295 !strcmp(arg, "--reflog") || !strcmp(arg, "--not") ||
2296 !strcmp(arg, "--no-walk") || !strcmp(arg, "--do-walk") ||
2297 !strcmp(arg, "--bisect") || starts_with(arg, "--glob=") ||
2298 !strcmp(arg, "--indexed-objects") ||
2299 !strcmp(arg, "--alternate-refs") ||
2300 starts_with(arg, "--exclude=") || starts_with(arg, "--exclude-hidden=") ||
2301 starts_with(arg, "--branches=") || starts_with(arg, "--tags=") ||
2302 starts_with(arg, "--remotes=") || starts_with(arg, "--no-walk="))
2304 unkv[(*unkc)++] = arg;
2305 return 1;
2308 if ((argcount = parse_long_opt("max-count", argv, &optarg))) {
2309 revs->max_count = parse_count(optarg);
2310 revs->no_walk = 0;
2311 return argcount;
2312 } else if ((argcount = parse_long_opt("skip", argv, &optarg))) {
2313 revs->skip_count = parse_count(optarg);
2314 return argcount;
2315 } else if ((*arg == '-') && isdigit(arg[1])) {
2316 /* accept -<digit>, like traditional "head" */
2317 revs->max_count = parse_count(arg + 1);
2318 revs->no_walk = 0;
2319 } else if (!strcmp(arg, "-n")) {
2320 if (argc <= 1)
2321 return error("-n requires an argument");
2322 revs->max_count = parse_count(argv[1]);
2323 revs->no_walk = 0;
2324 return 2;
2325 } else if (skip_prefix(arg, "-n", &optarg)) {
2326 revs->max_count = parse_count(optarg);
2327 revs->no_walk = 0;
2328 } else if ((argcount = parse_long_opt("max-age", argv, &optarg))) {
2329 revs->max_age = parse_age(optarg);
2330 return argcount;
2331 } else if ((argcount = parse_long_opt("since", argv, &optarg))) {
2332 revs->max_age = approxidate(optarg);
2333 return argcount;
2334 } else if ((argcount = parse_long_opt("since-as-filter", argv, &optarg))) {
2335 revs->max_age_as_filter = approxidate(optarg);
2336 return argcount;
2337 } else if ((argcount = parse_long_opt("after", argv, &optarg))) {
2338 revs->max_age = approxidate(optarg);
2339 return argcount;
2340 } else if ((argcount = parse_long_opt("min-age", argv, &optarg))) {
2341 revs->min_age = parse_age(optarg);
2342 return argcount;
2343 } else if ((argcount = parse_long_opt("before", argv, &optarg))) {
2344 revs->min_age = approxidate(optarg);
2345 return argcount;
2346 } else if ((argcount = parse_long_opt("until", argv, &optarg))) {
2347 revs->min_age = approxidate(optarg);
2348 return argcount;
2349 } else if (!strcmp(arg, "--first-parent")) {
2350 revs->first_parent_only = 1;
2351 } else if (!strcmp(arg, "--exclude-first-parent-only")) {
2352 revs->exclude_first_parent_only = 1;
2353 } else if (!strcmp(arg, "--ancestry-path")) {
2354 revs->ancestry_path = 1;
2355 revs->simplify_history = 0;
2356 revs->limited = 1;
2357 revs->ancestry_path_implicit_bottoms = 1;
2358 } else if (skip_prefix(arg, "--ancestry-path=", &optarg)) {
2359 struct commit *c;
2360 struct object_id oid;
2361 const char *msg = _("could not get commit for --ancestry-path argument %s");
2363 revs->ancestry_path = 1;
2364 revs->simplify_history = 0;
2365 revs->limited = 1;
2367 if (repo_get_oid_committish(revs->repo, optarg, &oid))
2368 return error(msg, optarg);
2369 get_reference(revs, optarg, &oid, ANCESTRY_PATH);
2370 c = lookup_commit_reference(revs->repo, &oid);
2371 if (!c)
2372 return error(msg, optarg);
2373 commit_list_insert(c, &revs->ancestry_path_bottoms);
2374 } else if (!strcmp(arg, "-g") || !strcmp(arg, "--walk-reflogs")) {
2375 init_reflog_walk(&revs->reflog_info);
2376 } else if (!strcmp(arg, "--default")) {
2377 if (argc <= 1)
2378 return error("bad --default argument");
2379 revs->def = argv[1];
2380 return 2;
2381 } else if (!strcmp(arg, "--merge")) {
2382 revs->show_merge = 1;
2383 } else if (!strcmp(arg, "--topo-order")) {
2384 revs->sort_order = REV_SORT_IN_GRAPH_ORDER;
2385 revs->topo_order = 1;
2386 } else if (!strcmp(arg, "--simplify-merges")) {
2387 revs->simplify_merges = 1;
2388 revs->topo_order = 1;
2389 revs->rewrite_parents = 1;
2390 revs->simplify_history = 0;
2391 revs->limited = 1;
2392 } else if (!strcmp(arg, "--simplify-by-decoration")) {
2393 revs->simplify_merges = 1;
2394 revs->topo_order = 1;
2395 revs->rewrite_parents = 1;
2396 revs->simplify_history = 0;
2397 revs->simplify_by_decoration = 1;
2398 revs->limited = 1;
2399 revs->prune = 1;
2400 } else if (!strcmp(arg, "--date-order")) {
2401 revs->sort_order = REV_SORT_BY_COMMIT_DATE;
2402 revs->topo_order = 1;
2403 } else if (!strcmp(arg, "--author-date-order")) {
2404 revs->sort_order = REV_SORT_BY_AUTHOR_DATE;
2405 revs->topo_order = 1;
2406 } else if (!strcmp(arg, "--early-output")) {
2407 revs->early_output = 100;
2408 revs->topo_order = 1;
2409 } else if (skip_prefix(arg, "--early-output=", &optarg)) {
2410 if (strtoul_ui(optarg, 10, &revs->early_output) < 0)
2411 die("'%s': not a non-negative integer", optarg);
2412 revs->topo_order = 1;
2413 } else if (!strcmp(arg, "--parents")) {
2414 revs->rewrite_parents = 1;
2415 revs->print_parents = 1;
2416 } else if (!strcmp(arg, "--dense")) {
2417 revs->dense = 1;
2418 } else if (!strcmp(arg, "--sparse")) {
2419 revs->dense = 0;
2420 } else if (!strcmp(arg, "--in-commit-order")) {
2421 revs->tree_blobs_in_commit_order = 1;
2422 } else if (!strcmp(arg, "--remove-empty")) {
2423 revs->remove_empty_trees = 1;
2424 } else if (!strcmp(arg, "--merges")) {
2425 revs->min_parents = 2;
2426 } else if (!strcmp(arg, "--no-merges")) {
2427 revs->max_parents = 1;
2428 } else if (skip_prefix(arg, "--min-parents=", &optarg)) {
2429 revs->min_parents = parse_count(optarg);
2430 } else if (!strcmp(arg, "--no-min-parents")) {
2431 revs->min_parents = 0;
2432 } else if (skip_prefix(arg, "--max-parents=", &optarg)) {
2433 revs->max_parents = parse_count(optarg);
2434 } else if (!strcmp(arg, "--no-max-parents")) {
2435 revs->max_parents = -1;
2436 } else if (!strcmp(arg, "--boundary")) {
2437 revs->boundary = 1;
2438 } else if (!strcmp(arg, "--left-right")) {
2439 revs->left_right = 1;
2440 } else if (!strcmp(arg, "--left-only")) {
2441 if (revs->right_only)
2442 die(_("options '%s' and '%s' cannot be used together"),
2443 "--left-only", "--right-only/--cherry");
2444 revs->left_only = 1;
2445 } else if (!strcmp(arg, "--right-only")) {
2446 if (revs->left_only)
2447 die(_("options '%s' and '%s' cannot be used together"), "--right-only", "--left-only");
2448 revs->right_only = 1;
2449 } else if (!strcmp(arg, "--cherry")) {
2450 if (revs->left_only)
2451 die(_("options '%s' and '%s' cannot be used together"), "--cherry", "--left-only");
2452 revs->cherry_mark = 1;
2453 revs->right_only = 1;
2454 revs->max_parents = 1;
2455 revs->limited = 1;
2456 } else if (!strcmp(arg, "--count")) {
2457 revs->count = 1;
2458 } else if (!strcmp(arg, "--cherry-mark")) {
2459 if (revs->cherry_pick)
2460 die(_("options '%s' and '%s' cannot be used together"), "--cherry-mark", "--cherry-pick");
2461 revs->cherry_mark = 1;
2462 revs->limited = 1; /* needs limit_list() */
2463 } else if (!strcmp(arg, "--cherry-pick")) {
2464 if (revs->cherry_mark)
2465 die(_("options '%s' and '%s' cannot be used together"), "--cherry-pick", "--cherry-mark");
2466 revs->cherry_pick = 1;
2467 revs->limited = 1;
2468 } else if (!strcmp(arg, "--objects")) {
2469 revs->tag_objects = 1;
2470 revs->tree_objects = 1;
2471 revs->blob_objects = 1;
2472 } else if (!strcmp(arg, "--objects-edge")) {
2473 revs->tag_objects = 1;
2474 revs->tree_objects = 1;
2475 revs->blob_objects = 1;
2476 revs->edge_hint = 1;
2477 } else if (!strcmp(arg, "--objects-edge-aggressive")) {
2478 revs->tag_objects = 1;
2479 revs->tree_objects = 1;
2480 revs->blob_objects = 1;
2481 revs->edge_hint = 1;
2482 revs->edge_hint_aggressive = 1;
2483 } else if (!strcmp(arg, "--verify-objects")) {
2484 revs->tag_objects = 1;
2485 revs->tree_objects = 1;
2486 revs->blob_objects = 1;
2487 revs->verify_objects = 1;
2488 disable_commit_graph(revs->repo);
2489 } else if (!strcmp(arg, "--unpacked")) {
2490 revs->unpacked = 1;
2491 } else if (starts_with(arg, "--unpacked=")) {
2492 die(_("--unpacked=<packfile> no longer supported"));
2493 } else if (!strcmp(arg, "--no-kept-objects")) {
2494 revs->no_kept_objects = 1;
2495 revs->keep_pack_cache_flags |= IN_CORE_KEEP_PACKS;
2496 revs->keep_pack_cache_flags |= ON_DISK_KEEP_PACKS;
2497 } else if (skip_prefix(arg, "--no-kept-objects=", &optarg)) {
2498 revs->no_kept_objects = 1;
2499 if (!strcmp(optarg, "in-core"))
2500 revs->keep_pack_cache_flags |= IN_CORE_KEEP_PACKS;
2501 if (!strcmp(optarg, "on-disk"))
2502 revs->keep_pack_cache_flags |= ON_DISK_KEEP_PACKS;
2503 } else if (!strcmp(arg, "-r")) {
2504 revs->diff = 1;
2505 revs->diffopt.flags.recursive = 1;
2506 } else if (!strcmp(arg, "-t")) {
2507 revs->diff = 1;
2508 revs->diffopt.flags.recursive = 1;
2509 revs->diffopt.flags.tree_in_recursive = 1;
2510 } else if ((argcount = diff_merges_parse_opts(revs, argv))) {
2511 return argcount;
2512 } else if (!strcmp(arg, "-v")) {
2513 revs->verbose_header = 1;
2514 } else if (!strcmp(arg, "--pretty")) {
2515 revs->verbose_header = 1;
2516 revs->pretty_given = 1;
2517 get_commit_format(NULL, revs);
2518 } else if (skip_prefix(arg, "--pretty=", &optarg) ||
2519 skip_prefix(arg, "--format=", &optarg)) {
2521 * Detached form ("--pretty X" as opposed to "--pretty=X")
2522 * not allowed, since the argument is optional.
2524 revs->verbose_header = 1;
2525 revs->pretty_given = 1;
2526 get_commit_format(optarg, revs);
2527 } else if (!strcmp(arg, "--expand-tabs")) {
2528 revs->expand_tabs_in_log = 8;
2529 } else if (!strcmp(arg, "--no-expand-tabs")) {
2530 revs->expand_tabs_in_log = 0;
2531 } else if (skip_prefix(arg, "--expand-tabs=", &arg)) {
2532 int val;
2533 if (strtol_i(arg, 10, &val) < 0 || val < 0)
2534 die("'%s': not a non-negative integer", arg);
2535 revs->expand_tabs_in_log = val;
2536 } else if (!strcmp(arg, "--show-notes") || !strcmp(arg, "--notes")) {
2537 enable_default_display_notes(&revs->notes_opt, &revs->show_notes);
2538 revs->show_notes_given = 1;
2539 } else if (!strcmp(arg, "--show-signature")) {
2540 revs->show_signature = 1;
2541 } else if (!strcmp(arg, "--no-show-signature")) {
2542 revs->show_signature = 0;
2543 } else if (!strcmp(arg, "--show-linear-break")) {
2544 revs->break_bar = " ..........";
2545 revs->track_linear = 1;
2546 revs->track_first_time = 1;
2547 } else if (skip_prefix(arg, "--show-linear-break=", &optarg)) {
2548 revs->break_bar = xstrdup(optarg);
2549 revs->track_linear = 1;
2550 revs->track_first_time = 1;
2551 } else if (!strcmp(arg, "--show-notes-by-default")) {
2552 revs->show_notes_by_default = 1;
2553 } else if (skip_prefix(arg, "--show-notes=", &optarg) ||
2554 skip_prefix(arg, "--notes=", &optarg)) {
2555 if (starts_with(arg, "--show-notes=") &&
2556 revs->notes_opt.use_default_notes < 0)
2557 revs->notes_opt.use_default_notes = 1;
2558 enable_ref_display_notes(&revs->notes_opt, &revs->show_notes, optarg);
2559 revs->show_notes_given = 1;
2560 } else if (!strcmp(arg, "--no-notes")) {
2561 disable_display_notes(&revs->notes_opt, &revs->show_notes);
2562 revs->show_notes_given = 1;
2563 } else if (!strcmp(arg, "--standard-notes")) {
2564 revs->show_notes_given = 1;
2565 revs->notes_opt.use_default_notes = 1;
2566 } else if (!strcmp(arg, "--no-standard-notes")) {
2567 revs->notes_opt.use_default_notes = 0;
2568 } else if (!strcmp(arg, "--oneline")) {
2569 revs->verbose_header = 1;
2570 get_commit_format("oneline", revs);
2571 revs->pretty_given = 1;
2572 revs->abbrev_commit = 1;
2573 } else if (!strcmp(arg, "--graph")) {
2574 graph_clear(revs->graph);
2575 revs->graph = graph_init(revs);
2576 } else if (!strcmp(arg, "--no-graph")) {
2577 graph_clear(revs->graph);
2578 revs->graph = NULL;
2579 } else if (!strcmp(arg, "--encode-email-headers")) {
2580 revs->encode_email_headers = 1;
2581 } else if (!strcmp(arg, "--no-encode-email-headers")) {
2582 revs->encode_email_headers = 0;
2583 } else if (!strcmp(arg, "--root")) {
2584 revs->show_root_diff = 1;
2585 } else if (!strcmp(arg, "--no-commit-id")) {
2586 revs->no_commit_id = 1;
2587 } else if (!strcmp(arg, "--always")) {
2588 revs->always_show_header = 1;
2589 } else if (!strcmp(arg, "--no-abbrev")) {
2590 revs->abbrev = 0;
2591 } else if (!strcmp(arg, "--abbrev")) {
2592 revs->abbrev = DEFAULT_ABBREV;
2593 } else if (skip_prefix(arg, "--abbrev=", &optarg)) {
2594 revs->abbrev = strtoul(optarg, NULL, 10);
2595 if (revs->abbrev < MINIMUM_ABBREV)
2596 revs->abbrev = MINIMUM_ABBREV;
2597 else if (revs->abbrev > hexsz)
2598 revs->abbrev = hexsz;
2599 } else if (!strcmp(arg, "--abbrev-commit")) {
2600 revs->abbrev_commit = 1;
2601 revs->abbrev_commit_given = 1;
2602 } else if (!strcmp(arg, "--no-abbrev-commit")) {
2603 revs->abbrev_commit = 0;
2604 } else if (!strcmp(arg, "--full-diff")) {
2605 revs->diff = 1;
2606 revs->full_diff = 1;
2607 } else if (!strcmp(arg, "--show-pulls")) {
2608 revs->show_pulls = 1;
2609 } else if (!strcmp(arg, "--full-history")) {
2610 revs->simplify_history = 0;
2611 } else if (!strcmp(arg, "--relative-date")) {
2612 revs->date_mode.type = DATE_RELATIVE;
2613 revs->date_mode_explicit = 1;
2614 } else if ((argcount = parse_long_opt("date", argv, &optarg))) {
2615 parse_date_format(optarg, &revs->date_mode);
2616 revs->date_mode_explicit = 1;
2617 return argcount;
2618 } else if (!strcmp(arg, "--log-size")) {
2619 revs->show_log_size = 1;
2622 * Grepping the commit log
2624 else if ((argcount = parse_long_opt("author", argv, &optarg))) {
2625 add_header_grep(revs, GREP_HEADER_AUTHOR, optarg);
2626 return argcount;
2627 } else if ((argcount = parse_long_opt("committer", argv, &optarg))) {
2628 add_header_grep(revs, GREP_HEADER_COMMITTER, optarg);
2629 return argcount;
2630 } else if ((argcount = parse_long_opt("grep-reflog", argv, &optarg))) {
2631 add_header_grep(revs, GREP_HEADER_REFLOG, optarg);
2632 return argcount;
2633 } else if ((argcount = parse_long_opt("grep", argv, &optarg))) {
2634 add_message_grep(revs, optarg);
2635 return argcount;
2636 } else if (!strcmp(arg, "--basic-regexp")) {
2637 revs->grep_filter.pattern_type_option = GREP_PATTERN_TYPE_BRE;
2638 } else if (!strcmp(arg, "--extended-regexp") || !strcmp(arg, "-E")) {
2639 revs->grep_filter.pattern_type_option = GREP_PATTERN_TYPE_ERE;
2640 } else if (!strcmp(arg, "--regexp-ignore-case") || !strcmp(arg, "-i")) {
2641 revs->grep_filter.ignore_case = 1;
2642 revs->diffopt.pickaxe_opts |= DIFF_PICKAXE_IGNORE_CASE;
2643 } else if (!strcmp(arg, "--fixed-strings") || !strcmp(arg, "-F")) {
2644 revs->grep_filter.pattern_type_option = GREP_PATTERN_TYPE_FIXED;
2645 } else if (!strcmp(arg, "--perl-regexp") || !strcmp(arg, "-P")) {
2646 revs->grep_filter.pattern_type_option = GREP_PATTERN_TYPE_PCRE;
2647 } else if (!strcmp(arg, "--all-match")) {
2648 revs->grep_filter.all_match = 1;
2649 } else if (!strcmp(arg, "--invert-grep")) {
2650 revs->grep_filter.no_body_match = 1;
2651 } else if ((argcount = parse_long_opt("encoding", argv, &optarg))) {
2652 if (strcmp(optarg, "none"))
2653 git_log_output_encoding = xstrdup(optarg);
2654 else
2655 git_log_output_encoding = "";
2656 return argcount;
2657 } else if (!strcmp(arg, "--reverse")) {
2658 revs->reverse ^= 1;
2659 } else if (!strcmp(arg, "--children")) {
2660 revs->children.name = "children";
2661 revs->limited = 1;
2662 } else if (!strcmp(arg, "--ignore-missing")) {
2663 revs->ignore_missing = 1;
2664 } else if (opt && opt->allow_exclude_promisor_objects &&
2665 !strcmp(arg, "--exclude-promisor-objects")) {
2666 if (fetch_if_missing)
2667 BUG("exclude_promisor_objects can only be used when fetch_if_missing is 0");
2668 revs->exclude_promisor_objects = 1;
2669 } else {
2670 int opts = diff_opt_parse(&revs->diffopt, argv, argc, revs->prefix);
2671 if (!opts)
2672 unkv[(*unkc)++] = arg;
2673 return opts;
2676 return 1;
2679 void parse_revision_opt(struct rev_info *revs, struct parse_opt_ctx_t *ctx,
2680 const struct option *options,
2681 const char * const usagestr[])
2683 int n = handle_revision_opt(revs, ctx->argc, ctx->argv,
2684 &ctx->cpidx, ctx->out, NULL);
2685 if (n <= 0) {
2686 error("unknown option `%s'", ctx->argv[0]);
2687 usage_with_options(usagestr, options);
2689 ctx->argv += n;
2690 ctx->argc -= n;
2693 void revision_opts_finish(struct rev_info *revs)
2695 if (revs->graph && revs->track_linear)
2696 die(_("options '%s' and '%s' cannot be used together"), "--show-linear-break", "--graph");
2698 if (revs->graph) {
2699 revs->topo_order = 1;
2700 revs->rewrite_parents = 1;
2704 static int for_each_bisect_ref(struct ref_store *refs, each_ref_fn fn,
2705 void *cb_data, const char *term)
2707 struct strbuf bisect_refs = STRBUF_INIT;
2708 int status;
2709 strbuf_addf(&bisect_refs, "refs/bisect/%s", term);
2710 status = refs_for_each_fullref_in(refs, bisect_refs.buf, NULL, fn, cb_data);
2711 strbuf_release(&bisect_refs);
2712 return status;
2715 static int for_each_bad_bisect_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
2717 return for_each_bisect_ref(refs, fn, cb_data, term_bad);
2720 static int for_each_good_bisect_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
2722 return for_each_bisect_ref(refs, fn, cb_data, term_good);
2725 static int handle_revision_pseudo_opt(struct rev_info *revs,
2726 const char **argv, int *flags)
2728 const char *arg = argv[0];
2729 const char *optarg;
2730 struct ref_store *refs;
2731 int argcount;
2733 if (revs->repo != the_repository) {
2735 * We need some something like get_submodule_worktrees()
2736 * before we can go through all worktrees of a submodule,
2737 * .e.g with adding all HEADs from --all, which is not
2738 * supported right now, so stick to single worktree.
2740 if (!revs->single_worktree)
2741 BUG("--single-worktree cannot be used together with submodule");
2743 refs = get_main_ref_store(revs->repo);
2746 * NOTE!
2748 * Commands like "git shortlog" will not accept the options below
2749 * unless parse_revision_opt queues them (as opposed to erroring
2750 * out).
2752 * When implementing your new pseudo-option, remember to
2753 * register it in the list at the top of handle_revision_opt.
2755 if (!strcmp(arg, "--all")) {
2756 handle_refs(refs, revs, *flags, refs_for_each_ref);
2757 handle_refs(refs, revs, *flags, refs_head_ref);
2758 if (!revs->single_worktree) {
2759 struct all_refs_cb cb;
2761 init_all_refs_cb(&cb, revs, *flags);
2762 other_head_refs(handle_one_ref, &cb);
2764 clear_ref_exclusions(&revs->ref_excludes);
2765 } else if (!strcmp(arg, "--branches")) {
2766 if (revs->ref_excludes.hidden_refs_configured)
2767 return error(_("options '%s' and '%s' cannot be used together"),
2768 "--exclude-hidden", "--branches");
2769 handle_refs(refs, revs, *flags, refs_for_each_branch_ref);
2770 clear_ref_exclusions(&revs->ref_excludes);
2771 } else if (!strcmp(arg, "--bisect")) {
2772 read_bisect_terms(&term_bad, &term_good);
2773 handle_refs(refs, revs, *flags, for_each_bad_bisect_ref);
2774 handle_refs(refs, revs, *flags ^ (UNINTERESTING | BOTTOM),
2775 for_each_good_bisect_ref);
2776 revs->bisect = 1;
2777 } else if (!strcmp(arg, "--tags")) {
2778 if (revs->ref_excludes.hidden_refs_configured)
2779 return error(_("options '%s' and '%s' cannot be used together"),
2780 "--exclude-hidden", "--tags");
2781 handle_refs(refs, revs, *flags, refs_for_each_tag_ref);
2782 clear_ref_exclusions(&revs->ref_excludes);
2783 } else if (!strcmp(arg, "--remotes")) {
2784 if (revs->ref_excludes.hidden_refs_configured)
2785 return error(_("options '%s' and '%s' cannot be used together"),
2786 "--exclude-hidden", "--remotes");
2787 handle_refs(refs, revs, *flags, refs_for_each_remote_ref);
2788 clear_ref_exclusions(&revs->ref_excludes);
2789 } else if ((argcount = parse_long_opt("glob", argv, &optarg))) {
2790 struct all_refs_cb cb;
2791 init_all_refs_cb(&cb, revs, *flags);
2792 for_each_glob_ref(handle_one_ref, optarg, &cb);
2793 clear_ref_exclusions(&revs->ref_excludes);
2794 return argcount;
2795 } else if ((argcount = parse_long_opt("exclude", argv, &optarg))) {
2796 add_ref_exclusion(&revs->ref_excludes, optarg);
2797 return argcount;
2798 } else if ((argcount = parse_long_opt("exclude-hidden", argv, &optarg))) {
2799 exclude_hidden_refs(&revs->ref_excludes, optarg);
2800 return argcount;
2801 } else if (skip_prefix(arg, "--branches=", &optarg)) {
2802 struct all_refs_cb cb;
2803 if (revs->ref_excludes.hidden_refs_configured)
2804 return error(_("options '%s' and '%s' cannot be used together"),
2805 "--exclude-hidden", "--branches");
2806 init_all_refs_cb(&cb, revs, *flags);
2807 for_each_glob_ref_in(handle_one_ref, optarg, "refs/heads/", &cb);
2808 clear_ref_exclusions(&revs->ref_excludes);
2809 } else if (skip_prefix(arg, "--tags=", &optarg)) {
2810 struct all_refs_cb cb;
2811 if (revs->ref_excludes.hidden_refs_configured)
2812 return error(_("options '%s' and '%s' cannot be used together"),
2813 "--exclude-hidden", "--tags");
2814 init_all_refs_cb(&cb, revs, *flags);
2815 for_each_glob_ref_in(handle_one_ref, optarg, "refs/tags/", &cb);
2816 clear_ref_exclusions(&revs->ref_excludes);
2817 } else if (skip_prefix(arg, "--remotes=", &optarg)) {
2818 struct all_refs_cb cb;
2819 if (revs->ref_excludes.hidden_refs_configured)
2820 return error(_("options '%s' and '%s' cannot be used together"),
2821 "--exclude-hidden", "--remotes");
2822 init_all_refs_cb(&cb, revs, *flags);
2823 for_each_glob_ref_in(handle_one_ref, optarg, "refs/remotes/", &cb);
2824 clear_ref_exclusions(&revs->ref_excludes);
2825 } else if (!strcmp(arg, "--reflog")) {
2826 add_reflogs_to_pending(revs, *flags);
2827 } else if (!strcmp(arg, "--indexed-objects")) {
2828 add_index_objects_to_pending(revs, *flags);
2829 } else if (!strcmp(arg, "--alternate-refs")) {
2830 add_alternate_refs_to_pending(revs, *flags);
2831 } else if (!strcmp(arg, "--not")) {
2832 *flags ^= UNINTERESTING | BOTTOM;
2833 } else if (!strcmp(arg, "--no-walk")) {
2834 revs->no_walk = 1;
2835 } else if (skip_prefix(arg, "--no-walk=", &optarg)) {
2837 * Detached form ("--no-walk X" as opposed to "--no-walk=X")
2838 * not allowed, since the argument is optional.
2840 revs->no_walk = 1;
2841 if (!strcmp(optarg, "sorted"))
2842 revs->unsorted_input = 0;
2843 else if (!strcmp(optarg, "unsorted"))
2844 revs->unsorted_input = 1;
2845 else
2846 return error("invalid argument to --no-walk");
2847 } else if (!strcmp(arg, "--do-walk")) {
2848 revs->no_walk = 0;
2849 } else if (!strcmp(arg, "--single-worktree")) {
2850 revs->single_worktree = 1;
2851 } else if (skip_prefix(arg, ("--filter="), &arg)) {
2852 parse_list_objects_filter(&revs->filter, arg);
2853 } else if (!strcmp(arg, ("--no-filter"))) {
2854 list_objects_filter_set_no_filter(&revs->filter);
2855 } else {
2856 return 0;
2859 return 1;
2862 static void read_revisions_from_stdin(struct rev_info *revs,
2863 struct strvec *prune)
2865 struct strbuf sb;
2866 int seen_dashdash = 0;
2867 int seen_end_of_options = 0;
2868 int save_warning;
2869 int flags = 0;
2871 save_warning = warn_on_object_refname_ambiguity;
2872 warn_on_object_refname_ambiguity = 0;
2874 strbuf_init(&sb, 1000);
2875 while (strbuf_getline(&sb, stdin) != EOF) {
2876 if (!sb.len)
2877 break;
2879 if (!strcmp(sb.buf, "--")) {
2880 seen_dashdash = 1;
2881 break;
2884 if (!seen_end_of_options && sb.buf[0] == '-') {
2885 const char *argv[] = { sb.buf, NULL };
2887 if (!strcmp(sb.buf, "--end-of-options")) {
2888 seen_end_of_options = 1;
2889 continue;
2892 if (handle_revision_pseudo_opt(revs, argv, &flags) > 0)
2893 continue;
2895 die(_("invalid option '%s' in --stdin mode"), sb.buf);
2898 if (handle_revision_arg(sb.buf, revs, flags,
2899 REVARG_CANNOT_BE_FILENAME))
2900 die("bad revision '%s'", sb.buf);
2902 if (seen_dashdash)
2903 read_pathspec_from_stdin(&sb, prune);
2905 strbuf_release(&sb);
2906 warn_on_object_refname_ambiguity = save_warning;
2909 static void NORETURN diagnose_missing_default(const char *def)
2911 int flags;
2912 const char *refname;
2914 refname = resolve_ref_unsafe(def, 0, NULL, &flags);
2915 if (!refname || !(flags & REF_ISSYMREF) || (flags & REF_ISBROKEN))
2916 die(_("your current branch appears to be broken"));
2918 skip_prefix(refname, "refs/heads/", &refname);
2919 die(_("your current branch '%s' does not have any commits yet"),
2920 refname);
2924 * Parse revision information, filling in the "rev_info" structure,
2925 * and removing the used arguments from the argument list.
2927 * Returns the number of arguments left that weren't recognized
2928 * (which are also moved to the head of the argument list)
2930 int setup_revisions(int argc, const char **argv, struct rev_info *revs, struct setup_revision_opt *opt)
2932 int i, flags, left, seen_dashdash, revarg_opt;
2933 struct strvec prune_data = STRVEC_INIT;
2934 int seen_end_of_options = 0;
2936 /* First, search for "--" */
2937 if (opt && opt->assume_dashdash) {
2938 seen_dashdash = 1;
2939 } else {
2940 seen_dashdash = 0;
2941 for (i = 1; i < argc; i++) {
2942 const char *arg = argv[i];
2943 if (strcmp(arg, "--"))
2944 continue;
2945 if (opt && opt->free_removed_argv_elements)
2946 free((char *)argv[i]);
2947 argv[i] = NULL;
2948 argc = i;
2949 if (argv[i + 1])
2950 strvec_pushv(&prune_data, argv + i + 1);
2951 seen_dashdash = 1;
2952 break;
2956 /* Second, deal with arguments and options */
2957 flags = 0;
2958 revarg_opt = opt ? opt->revarg_opt : 0;
2959 if (seen_dashdash)
2960 revarg_opt |= REVARG_CANNOT_BE_FILENAME;
2961 for (left = i = 1; i < argc; i++) {
2962 const char *arg = argv[i];
2963 if (!seen_end_of_options && *arg == '-') {
2964 int opts;
2966 opts = handle_revision_pseudo_opt(
2967 revs, argv + i,
2968 &flags);
2969 if (opts > 0) {
2970 i += opts - 1;
2971 continue;
2974 if (!strcmp(arg, "--stdin")) {
2975 if (revs->disable_stdin) {
2976 argv[left++] = arg;
2977 continue;
2979 if (revs->read_from_stdin++)
2980 die("--stdin given twice?");
2981 read_revisions_from_stdin(revs, &prune_data);
2982 continue;
2985 if (!strcmp(arg, "--end-of-options")) {
2986 seen_end_of_options = 1;
2987 continue;
2990 opts = handle_revision_opt(revs, argc - i, argv + i,
2991 &left, argv, opt);
2992 if (opts > 0) {
2993 i += opts - 1;
2994 continue;
2996 if (opts < 0)
2997 exit(128);
2998 continue;
3002 if (handle_revision_arg(arg, revs, flags, revarg_opt)) {
3003 int j;
3004 if (seen_dashdash || *arg == '^')
3005 die("bad revision '%s'", arg);
3007 /* If we didn't have a "--":
3008 * (1) all filenames must exist;
3009 * (2) all rev-args must not be interpretable
3010 * as a valid filename.
3011 * but the latter we have checked in the main loop.
3013 for (j = i; j < argc; j++)
3014 verify_filename(revs->prefix, argv[j], j == i);
3016 strvec_pushv(&prune_data, argv + i);
3017 break;
3020 revision_opts_finish(revs);
3022 if (prune_data.nr) {
3024 * If we need to introduce the magic "a lone ':' means no
3025 * pathspec whatsoever", here is the place to do so.
3027 * if (prune_data.nr == 1 && !strcmp(prune_data[0], ":")) {
3028 * prune_data.nr = 0;
3029 * prune_data.alloc = 0;
3030 * free(prune_data.path);
3031 * prune_data.path = NULL;
3032 * } else {
3033 * terminate prune_data.alloc with NULL and
3034 * call init_pathspec() to set revs->prune_data here.
3037 parse_pathspec(&revs->prune_data, 0, 0,
3038 revs->prefix, prune_data.v);
3040 strvec_clear(&prune_data);
3042 if (!revs->def)
3043 revs->def = opt ? opt->def : NULL;
3044 if (opt && opt->tweak)
3045 opt->tweak(revs);
3046 if (revs->show_merge)
3047 prepare_show_merge(revs);
3048 if (revs->def && !revs->pending.nr && !revs->rev_input_given) {
3049 struct object_id oid;
3050 struct object *object;
3051 struct object_context oc;
3052 if (get_oid_with_context(revs->repo, revs->def, 0, &oid, &oc))
3053 diagnose_missing_default(revs->def);
3054 object = get_reference(revs, revs->def, &oid, 0);
3055 add_pending_object_with_mode(revs, object, revs->def, oc.mode);
3058 /* Did the user ask for any diff output? Run the diff! */
3059 if (revs->diffopt.output_format & ~DIFF_FORMAT_NO_OUTPUT)
3060 revs->diff = 1;
3062 /* Pickaxe, diff-filter and rename following need diffs */
3063 if ((revs->diffopt.pickaxe_opts & DIFF_PICKAXE_KINDS_MASK) ||
3064 revs->diffopt.filter ||
3065 revs->diffopt.flags.follow_renames)
3066 revs->diff = 1;
3068 if (revs->diffopt.objfind)
3069 revs->simplify_history = 0;
3071 if (revs->line_level_traverse) {
3072 if (want_ancestry(revs))
3073 revs->limited = 1;
3074 revs->topo_order = 1;
3077 if (revs->topo_order && !generation_numbers_enabled(the_repository))
3078 revs->limited = 1;
3080 if (revs->prune_data.nr) {
3081 copy_pathspec(&revs->pruning.pathspec, &revs->prune_data);
3082 /* Can't prune commits with rename following: the paths change.. */
3083 if (!revs->diffopt.flags.follow_renames)
3084 revs->prune = 1;
3085 if (!revs->full_diff)
3086 copy_pathspec(&revs->diffopt.pathspec,
3087 &revs->prune_data);
3090 diff_merges_setup_revs(revs);
3092 revs->diffopt.abbrev = revs->abbrev;
3094 diff_setup_done(&revs->diffopt);
3096 if (!is_encoding_utf8(get_log_output_encoding()))
3097 revs->grep_filter.ignore_locale = 1;
3098 compile_grep_patterns(&revs->grep_filter);
3100 if (revs->reflog_info && revs->limited)
3101 die("cannot combine --walk-reflogs with history-limiting options");
3102 if (revs->rewrite_parents && revs->children.name)
3103 die(_("options '%s' and '%s' cannot be used together"), "--parents", "--children");
3104 if (revs->filter.choice && !revs->blob_objects)
3105 die(_("object filtering requires --objects"));
3108 * Limitations on the graph functionality
3110 die_for_incompatible_opt3(!!revs->graph, "--graph",
3111 !!revs->reverse, "--reverse",
3112 !!revs->reflog_info, "--walk-reflogs");
3114 if (revs->no_walk && revs->graph)
3115 die(_("options '%s' and '%s' cannot be used together"), "--no-walk", "--graph");
3116 if (!revs->reflog_info && revs->grep_filter.use_reflog_filter)
3117 die(_("the option '%s' requires '%s'"), "--grep-reflog", "--walk-reflogs");
3119 if (revs->line_level_traverse &&
3120 (revs->diffopt.output_format & ~(DIFF_FORMAT_PATCH | DIFF_FORMAT_NO_OUTPUT)))
3121 die(_("-L does not yet support diff formats besides -p and -s"));
3123 if (revs->expand_tabs_in_log < 0)
3124 revs->expand_tabs_in_log = revs->expand_tabs_in_log_default;
3126 if (!revs->show_notes_given && revs->show_notes_by_default) {
3127 enable_default_display_notes(&revs->notes_opt, &revs->show_notes);
3128 revs->show_notes_given = 1;
3131 return left;
3134 static void release_revisions_cmdline(struct rev_cmdline_info *cmdline)
3136 unsigned int i;
3138 for (i = 0; i < cmdline->nr; i++)
3139 free((char *)cmdline->rev[i].name);
3140 free(cmdline->rev);
3143 static void release_revisions_mailmap(struct string_list *mailmap)
3145 if (!mailmap)
3146 return;
3147 clear_mailmap(mailmap);
3148 free(mailmap);
3151 static void release_revisions_topo_walk_info(struct topo_walk_info *info);
3153 static void free_void_commit_list(void *list)
3155 free_commit_list(list);
3158 void release_revisions(struct rev_info *revs)
3160 free_commit_list(revs->commits);
3161 free_commit_list(revs->ancestry_path_bottoms);
3162 object_array_clear(&revs->pending);
3163 object_array_clear(&revs->boundary_commits);
3164 release_revisions_cmdline(&revs->cmdline);
3165 list_objects_filter_release(&revs->filter);
3166 clear_pathspec(&revs->prune_data);
3167 date_mode_release(&revs->date_mode);
3168 release_revisions_mailmap(revs->mailmap);
3169 free_grep_patterns(&revs->grep_filter);
3170 graph_clear(revs->graph);
3171 /* TODO (need to handle "no_free"): diff_free(&revs->diffopt) */
3172 diff_free(&revs->pruning);
3173 reflog_walk_info_release(revs->reflog_info);
3174 release_revisions_topo_walk_info(revs->topo_walk_info);
3175 clear_decoration(&revs->children, free_void_commit_list);
3176 clear_decoration(&revs->merge_simplification, free);
3177 clear_decoration(&revs->treesame, free);
3178 line_log_free(revs);
3179 oidset_clear(&revs->missing_commits);
3182 static void add_child(struct rev_info *revs, struct commit *parent, struct commit *child)
3184 struct commit_list *l = xcalloc(1, sizeof(*l));
3186 l->item = child;
3187 l->next = add_decoration(&revs->children, &parent->object, l);
3190 static int remove_duplicate_parents(struct rev_info *revs, struct commit *commit)
3192 struct treesame_state *ts = lookup_decoration(&revs->treesame, &commit->object);
3193 struct commit_list **pp, *p;
3194 int surviving_parents;
3196 /* Examine existing parents while marking ones we have seen... */
3197 pp = &commit->parents;
3198 surviving_parents = 0;
3199 while ((p = *pp) != NULL) {
3200 struct commit *parent = p->item;
3201 if (parent->object.flags & TMP_MARK) {
3202 *pp = p->next;
3203 if (ts)
3204 compact_treesame(revs, commit, surviving_parents);
3205 continue;
3207 parent->object.flags |= TMP_MARK;
3208 surviving_parents++;
3209 pp = &p->next;
3211 /* clear the temporary mark */
3212 for (p = commit->parents; p; p = p->next) {
3213 p->item->object.flags &= ~TMP_MARK;
3215 /* no update_treesame() - removing duplicates can't affect TREESAME */
3216 return surviving_parents;
3219 struct merge_simplify_state {
3220 struct commit *simplified;
3223 static struct merge_simplify_state *locate_simplify_state(struct rev_info *revs, struct commit *commit)
3225 struct merge_simplify_state *st;
3227 st = lookup_decoration(&revs->merge_simplification, &commit->object);
3228 if (!st) {
3229 CALLOC_ARRAY(st, 1);
3230 add_decoration(&revs->merge_simplification, &commit->object, st);
3232 return st;
3235 static int mark_redundant_parents(struct commit *commit)
3237 struct commit_list *h = reduce_heads(commit->parents);
3238 int i = 0, marked = 0;
3239 struct commit_list *po, *pn;
3241 /* Want these for sanity-checking only */
3242 int orig_cnt = commit_list_count(commit->parents);
3243 int cnt = commit_list_count(h);
3246 * Not ready to remove items yet, just mark them for now, based
3247 * on the output of reduce_heads(). reduce_heads outputs the reduced
3248 * set in its original order, so this isn't too hard.
3250 po = commit->parents;
3251 pn = h;
3252 while (po) {
3253 if (pn && po->item == pn->item) {
3254 pn = pn->next;
3255 i++;
3256 } else {
3257 po->item->object.flags |= TMP_MARK;
3258 marked++;
3260 po=po->next;
3263 if (i != cnt || cnt+marked != orig_cnt)
3264 die("mark_redundant_parents %d %d %d %d", orig_cnt, cnt, i, marked);
3266 free_commit_list(h);
3268 return marked;
3271 static int mark_treesame_root_parents(struct commit *commit)
3273 struct commit_list *p;
3274 int marked = 0;
3276 for (p = commit->parents; p; p = p->next) {
3277 struct commit *parent = p->item;
3278 if (!parent->parents && (parent->object.flags & TREESAME)) {
3279 parent->object.flags |= TMP_MARK;
3280 marked++;
3284 return marked;
3288 * Awkward naming - this means one parent we are TREESAME to.
3289 * cf mark_treesame_root_parents: root parents that are TREESAME (to an
3290 * empty tree). Better name suggestions?
3292 static int leave_one_treesame_to_parent(struct rev_info *revs, struct commit *commit)
3294 struct treesame_state *ts = lookup_decoration(&revs->treesame, &commit->object);
3295 struct commit *unmarked = NULL, *marked = NULL;
3296 struct commit_list *p;
3297 unsigned n;
3299 for (p = commit->parents, n = 0; p; p = p->next, n++) {
3300 if (ts->treesame[n]) {
3301 if (p->item->object.flags & TMP_MARK) {
3302 if (!marked)
3303 marked = p->item;
3304 } else {
3305 if (!unmarked) {
3306 unmarked = p->item;
3307 break;
3314 * If we are TREESAME to a marked-for-deletion parent, but not to any
3315 * unmarked parents, unmark the first TREESAME parent. This is the
3316 * parent that the default simplify_history==1 scan would have followed,
3317 * and it doesn't make sense to omit that path when asking for a
3318 * simplified full history. Retaining it improves the chances of
3319 * understanding odd missed merges that took an old version of a file.
3321 * Example:
3323 * I--------*X A modified the file, but mainline merge X used
3324 * \ / "-s ours", so took the version from I. X is
3325 * `-*A--' TREESAME to I and !TREESAME to A.
3327 * Default log from X would produce "I". Without this check,
3328 * --full-history --simplify-merges would produce "I-A-X", showing
3329 * the merge commit X and that it changed A, but not making clear that
3330 * it had just taken the I version. With this check, the topology above
3331 * is retained.
3333 * Note that it is possible that the simplification chooses a different
3334 * TREESAME parent from the default, in which case this test doesn't
3335 * activate, and we _do_ drop the default parent. Example:
3337 * I------X A modified the file, but it was reverted in B,
3338 * \ / meaning mainline merge X is TREESAME to both
3339 * *A-*B parents.
3341 * Default log would produce "I" by following the first parent;
3342 * --full-history --simplify-merges will produce "I-A-B". But this is a
3343 * reasonable result - it presents a logical full history leading from
3344 * I to X, and X is not an important merge.
3346 if (!unmarked && marked) {
3347 marked->object.flags &= ~TMP_MARK;
3348 return 1;
3351 return 0;
3354 static int remove_marked_parents(struct rev_info *revs, struct commit *commit)
3356 struct commit_list **pp, *p;
3357 int nth_parent, removed = 0;
3359 pp = &commit->parents;
3360 nth_parent = 0;
3361 while ((p = *pp) != NULL) {
3362 struct commit *parent = p->item;
3363 if (parent->object.flags & TMP_MARK) {
3364 parent->object.flags &= ~TMP_MARK;
3365 *pp = p->next;
3366 free(p);
3367 removed++;
3368 compact_treesame(revs, commit, nth_parent);
3369 continue;
3371 pp = &p->next;
3372 nth_parent++;
3375 /* Removing parents can only increase TREESAMEness */
3376 if (removed && !(commit->object.flags & TREESAME))
3377 update_treesame(revs, commit);
3379 return nth_parent;
3382 static struct commit_list **simplify_one(struct rev_info *revs, struct commit *commit, struct commit_list **tail)
3384 struct commit_list *p;
3385 struct commit *parent;
3386 struct merge_simplify_state *st, *pst;
3387 int cnt;
3389 st = locate_simplify_state(revs, commit);
3392 * Have we handled this one?
3394 if (st->simplified)
3395 return tail;
3398 * An UNINTERESTING commit simplifies to itself, so does a
3399 * root commit. We do not rewrite parents of such commit
3400 * anyway.
3402 if ((commit->object.flags & UNINTERESTING) || !commit->parents) {
3403 st->simplified = commit;
3404 return tail;
3408 * Do we know what commit all of our parents that matter
3409 * should be rewritten to? Otherwise we are not ready to
3410 * rewrite this one yet.
3412 for (cnt = 0, p = commit->parents; p; p = p->next) {
3413 pst = locate_simplify_state(revs, p->item);
3414 if (!pst->simplified) {
3415 tail = &commit_list_insert(p->item, tail)->next;
3416 cnt++;
3418 if (revs->first_parent_only)
3419 break;
3421 if (cnt) {
3422 tail = &commit_list_insert(commit, tail)->next;
3423 return tail;
3427 * Rewrite our list of parents. Note that this cannot
3428 * affect our TREESAME flags in any way - a commit is
3429 * always TREESAME to its simplification.
3431 for (p = commit->parents; p; p = p->next) {
3432 pst = locate_simplify_state(revs, p->item);
3433 p->item = pst->simplified;
3434 if (revs->first_parent_only)
3435 break;
3438 if (revs->first_parent_only)
3439 cnt = 1;
3440 else
3441 cnt = remove_duplicate_parents(revs, commit);
3444 * It is possible that we are a merge and one side branch
3445 * does not have any commit that touches the given paths;
3446 * in such a case, the immediate parent from that branch
3447 * will be rewritten to be the merge base.
3449 * o----X X: the commit we are looking at;
3450 * / / o: a commit that touches the paths;
3451 * ---o----'
3453 * Further, a merge of an independent branch that doesn't
3454 * touch the path will reduce to a treesame root parent:
3456 * ----o----X X: the commit we are looking at;
3457 * / o: a commit that touches the paths;
3458 * r r: a root commit not touching the paths
3460 * Detect and simplify both cases.
3462 if (1 < cnt) {
3463 int marked = mark_redundant_parents(commit);
3464 marked += mark_treesame_root_parents(commit);
3465 if (marked)
3466 marked -= leave_one_treesame_to_parent(revs, commit);
3467 if (marked)
3468 cnt = remove_marked_parents(revs, commit);
3472 * A commit simplifies to itself if it is a root, if it is
3473 * UNINTERESTING, if it touches the given paths, or if it is a
3474 * merge and its parents don't simplify to one relevant commit
3475 * (the first two cases are already handled at the beginning of
3476 * this function).
3478 * Otherwise, it simplifies to what its sole relevant parent
3479 * simplifies to.
3481 if (!cnt ||
3482 (commit->object.flags & UNINTERESTING) ||
3483 !(commit->object.flags & TREESAME) ||
3484 (parent = one_relevant_parent(revs, commit->parents)) == NULL ||
3485 (revs->show_pulls && (commit->object.flags & PULL_MERGE)))
3486 st->simplified = commit;
3487 else {
3488 pst = locate_simplify_state(revs, parent);
3489 st->simplified = pst->simplified;
3491 return tail;
3494 static void simplify_merges(struct rev_info *revs)
3496 struct commit_list *list, *next;
3497 struct commit_list *yet_to_do, **tail;
3498 struct commit *commit;
3500 if (!revs->prune)
3501 return;
3503 /* feed the list reversed */
3504 yet_to_do = NULL;
3505 for (list = revs->commits; list; list = next) {
3506 commit = list->item;
3507 next = list->next;
3509 * Do not free(list) here yet; the original list
3510 * is used later in this function.
3512 commit_list_insert(commit, &yet_to_do);
3514 while (yet_to_do) {
3515 list = yet_to_do;
3516 yet_to_do = NULL;
3517 tail = &yet_to_do;
3518 while (list) {
3519 commit = pop_commit(&list);
3520 tail = simplify_one(revs, commit, tail);
3524 /* clean up the result, removing the simplified ones */
3525 list = revs->commits;
3526 revs->commits = NULL;
3527 tail = &revs->commits;
3528 while (list) {
3529 struct merge_simplify_state *st;
3531 commit = pop_commit(&list);
3532 st = locate_simplify_state(revs, commit);
3533 if (st->simplified == commit)
3534 tail = &commit_list_insert(commit, tail)->next;
3538 static void set_children(struct rev_info *revs)
3540 struct commit_list *l;
3541 for (l = revs->commits; l; l = l->next) {
3542 struct commit *commit = l->item;
3543 struct commit_list *p;
3545 for (p = commit->parents; p; p = p->next)
3546 add_child(revs, p->item, commit);
3550 void reset_revision_walk(void)
3552 clear_object_flags(SEEN | ADDED | SHOWN | TOPO_WALK_EXPLORED | TOPO_WALK_INDEGREE);
3555 static int mark_uninteresting(const struct object_id *oid,
3556 struct packed_git *pack UNUSED,
3557 uint32_t pos UNUSED,
3558 void *cb)
3560 struct rev_info *revs = cb;
3561 struct object *o = lookup_unknown_object(revs->repo, oid);
3562 o->flags |= UNINTERESTING | SEEN;
3563 return 0;
3566 define_commit_slab(indegree_slab, int);
3567 define_commit_slab(author_date_slab, timestamp_t);
3569 struct topo_walk_info {
3570 timestamp_t min_generation;
3571 struct prio_queue explore_queue;
3572 struct prio_queue indegree_queue;
3573 struct prio_queue topo_queue;
3574 struct indegree_slab indegree;
3575 struct author_date_slab author_date;
3578 static int topo_walk_atexit_registered;
3579 static unsigned int count_explore_walked;
3580 static unsigned int count_indegree_walked;
3581 static unsigned int count_topo_walked;
3583 static void trace2_topo_walk_statistics_atexit(void)
3585 struct json_writer jw = JSON_WRITER_INIT;
3587 jw_object_begin(&jw, 0);
3588 jw_object_intmax(&jw, "count_explore_walked", count_explore_walked);
3589 jw_object_intmax(&jw, "count_indegree_walked", count_indegree_walked);
3590 jw_object_intmax(&jw, "count_topo_walked", count_topo_walked);
3591 jw_end(&jw);
3593 trace2_data_json("topo_walk", the_repository, "statistics", &jw);
3595 jw_release(&jw);
3598 static inline void test_flag_and_insert(struct prio_queue *q, struct commit *c, int flag)
3600 if (c->object.flags & flag)
3601 return;
3603 c->object.flags |= flag;
3604 prio_queue_put(q, c);
3607 static void explore_walk_step(struct rev_info *revs)
3609 struct topo_walk_info *info = revs->topo_walk_info;
3610 struct commit_list *p;
3611 struct commit *c = prio_queue_get(&info->explore_queue);
3613 if (!c)
3614 return;
3616 if (repo_parse_commit_gently(revs->repo, c, 1) < 0)
3617 return;
3619 count_explore_walked++;
3621 if (revs->sort_order == REV_SORT_BY_AUTHOR_DATE)
3622 record_author_date(&info->author_date, c);
3624 if (revs->max_age != -1 && (c->date < revs->max_age))
3625 c->object.flags |= UNINTERESTING;
3627 if (process_parents(revs, c, NULL, NULL) < 0)
3628 return;
3630 if (c->object.flags & UNINTERESTING)
3631 mark_parents_uninteresting(revs, c);
3633 for (p = c->parents; p; p = p->next)
3634 test_flag_and_insert(&info->explore_queue, p->item, TOPO_WALK_EXPLORED);
3637 static void explore_to_depth(struct rev_info *revs,
3638 timestamp_t gen_cutoff)
3640 struct topo_walk_info *info = revs->topo_walk_info;
3641 struct commit *c;
3642 while ((c = prio_queue_peek(&info->explore_queue)) &&
3643 commit_graph_generation(c) >= gen_cutoff)
3644 explore_walk_step(revs);
3647 static void indegree_walk_step(struct rev_info *revs)
3649 struct commit_list *p;
3650 struct topo_walk_info *info = revs->topo_walk_info;
3651 struct commit *c = prio_queue_get(&info->indegree_queue);
3653 if (!c)
3654 return;
3656 if (repo_parse_commit_gently(revs->repo, c, 1) < 0)
3657 return;
3659 count_indegree_walked++;
3661 explore_to_depth(revs, commit_graph_generation(c));
3663 for (p = c->parents; p; p = p->next) {
3664 struct commit *parent = p->item;
3665 int *pi = indegree_slab_at(&info->indegree, parent);
3667 if (repo_parse_commit_gently(revs->repo, parent, 1) < 0)
3668 return;
3670 if (*pi)
3671 (*pi)++;
3672 else
3673 *pi = 2;
3675 test_flag_and_insert(&info->indegree_queue, parent, TOPO_WALK_INDEGREE);
3677 if (revs->first_parent_only)
3678 return;
3682 static void compute_indegrees_to_depth(struct rev_info *revs,
3683 timestamp_t gen_cutoff)
3685 struct topo_walk_info *info = revs->topo_walk_info;
3686 struct commit *c;
3687 while ((c = prio_queue_peek(&info->indegree_queue)) &&
3688 commit_graph_generation(c) >= gen_cutoff)
3689 indegree_walk_step(revs);
3692 static void release_revisions_topo_walk_info(struct topo_walk_info *info)
3694 if (!info)
3695 return;
3696 clear_prio_queue(&info->explore_queue);
3697 clear_prio_queue(&info->indegree_queue);
3698 clear_prio_queue(&info->topo_queue);
3699 clear_indegree_slab(&info->indegree);
3700 clear_author_date_slab(&info->author_date);
3701 free(info);
3704 static void reset_topo_walk(struct rev_info *revs)
3706 release_revisions_topo_walk_info(revs->topo_walk_info);
3707 revs->topo_walk_info = NULL;
3710 static void init_topo_walk(struct rev_info *revs)
3712 struct topo_walk_info *info;
3713 struct commit_list *list;
3714 if (revs->topo_walk_info)
3715 reset_topo_walk(revs);
3717 revs->topo_walk_info = xmalloc(sizeof(struct topo_walk_info));
3718 info = revs->topo_walk_info;
3719 memset(info, 0, sizeof(struct topo_walk_info));
3721 init_indegree_slab(&info->indegree);
3722 memset(&info->explore_queue, 0, sizeof(info->explore_queue));
3723 memset(&info->indegree_queue, 0, sizeof(info->indegree_queue));
3724 memset(&info->topo_queue, 0, sizeof(info->topo_queue));
3726 switch (revs->sort_order) {
3727 default: /* REV_SORT_IN_GRAPH_ORDER */
3728 info->topo_queue.compare = NULL;
3729 break;
3730 case REV_SORT_BY_COMMIT_DATE:
3731 info->topo_queue.compare = compare_commits_by_commit_date;
3732 break;
3733 case REV_SORT_BY_AUTHOR_DATE:
3734 init_author_date_slab(&info->author_date);
3735 info->topo_queue.compare = compare_commits_by_author_date;
3736 info->topo_queue.cb_data = &info->author_date;
3737 break;
3740 info->explore_queue.compare = compare_commits_by_gen_then_commit_date;
3741 info->indegree_queue.compare = compare_commits_by_gen_then_commit_date;
3743 info->min_generation = GENERATION_NUMBER_INFINITY;
3744 for (list = revs->commits; list; list = list->next) {
3745 struct commit *c = list->item;
3746 timestamp_t generation;
3748 if (repo_parse_commit_gently(revs->repo, c, 1))
3749 continue;
3751 test_flag_and_insert(&info->explore_queue, c, TOPO_WALK_EXPLORED);
3752 test_flag_and_insert(&info->indegree_queue, c, TOPO_WALK_INDEGREE);
3754 generation = commit_graph_generation(c);
3755 if (generation < info->min_generation)
3756 info->min_generation = generation;
3758 *(indegree_slab_at(&info->indegree, c)) = 1;
3760 if (revs->sort_order == REV_SORT_BY_AUTHOR_DATE)
3761 record_author_date(&info->author_date, c);
3763 compute_indegrees_to_depth(revs, info->min_generation);
3765 for (list = revs->commits; list; list = list->next) {
3766 struct commit *c = list->item;
3768 if (*(indegree_slab_at(&info->indegree, c)) == 1)
3769 prio_queue_put(&info->topo_queue, c);
3773 * This is unfortunate; the initial tips need to be shown
3774 * in the order given from the revision traversal machinery.
3776 if (revs->sort_order == REV_SORT_IN_GRAPH_ORDER)
3777 prio_queue_reverse(&info->topo_queue);
3779 if (trace2_is_enabled() && !topo_walk_atexit_registered) {
3780 atexit(trace2_topo_walk_statistics_atexit);
3781 topo_walk_atexit_registered = 1;
3785 static struct commit *next_topo_commit(struct rev_info *revs)
3787 struct commit *c;
3788 struct topo_walk_info *info = revs->topo_walk_info;
3790 /* pop next off of topo_queue */
3791 c = prio_queue_get(&info->topo_queue);
3793 if (c)
3794 *(indegree_slab_at(&info->indegree, c)) = 0;
3796 return c;
3799 static void expand_topo_walk(struct rev_info *revs, struct commit *commit)
3801 struct commit_list *p;
3802 struct topo_walk_info *info = revs->topo_walk_info;
3803 if (process_parents(revs, commit, NULL, NULL) < 0) {
3804 if (!revs->ignore_missing_links)
3805 die("Failed to traverse parents of commit %s",
3806 oid_to_hex(&commit->object.oid));
3809 count_topo_walked++;
3811 for (p = commit->parents; p; p = p->next) {
3812 struct commit *parent = p->item;
3813 int *pi;
3814 timestamp_t generation;
3816 if (parent->object.flags & UNINTERESTING)
3817 continue;
3819 if (repo_parse_commit_gently(revs->repo, parent, 1) < 0)
3820 continue;
3822 generation = commit_graph_generation(parent);
3823 if (generation < info->min_generation) {
3824 info->min_generation = generation;
3825 compute_indegrees_to_depth(revs, info->min_generation);
3828 pi = indegree_slab_at(&info->indegree, parent);
3830 (*pi)--;
3831 if (*pi == 1)
3832 prio_queue_put(&info->topo_queue, parent);
3834 if (revs->first_parent_only)
3835 return;
3839 int prepare_revision_walk(struct rev_info *revs)
3841 int i;
3842 struct object_array old_pending;
3843 struct commit_list **next = &revs->commits;
3845 memcpy(&old_pending, &revs->pending, sizeof(old_pending));
3846 revs->pending.nr = 0;
3847 revs->pending.alloc = 0;
3848 revs->pending.objects = NULL;
3849 for (i = 0; i < old_pending.nr; i++) {
3850 struct object_array_entry *e = old_pending.objects + i;
3851 struct commit *commit = handle_commit(revs, e);
3852 if (commit) {
3853 if (!(commit->object.flags & SEEN)) {
3854 commit->object.flags |= SEEN;
3855 next = commit_list_append(commit, next);
3859 object_array_clear(&old_pending);
3861 /* Signal whether we need per-parent treesame decoration */
3862 if (revs->simplify_merges ||
3863 (revs->limited && limiting_can_increase_treesame(revs)))
3864 revs->treesame.name = "treesame";
3866 if (revs->exclude_promisor_objects) {
3867 for_each_packed_object(mark_uninteresting, revs,
3868 FOR_EACH_OBJECT_PROMISOR_ONLY);
3871 if (!revs->reflog_info)
3872 prepare_to_use_bloom_filter(revs);
3873 if (!revs->unsorted_input)
3874 commit_list_sort_by_date(&revs->commits);
3875 if (revs->no_walk)
3876 return 0;
3877 if (revs->limited) {
3878 if (limit_list(revs) < 0)
3879 return -1;
3880 if (revs->topo_order)
3881 sort_in_topological_order(&revs->commits, revs->sort_order);
3882 } else if (revs->topo_order)
3883 init_topo_walk(revs);
3884 if (revs->line_level_traverse && want_ancestry(revs))
3886 * At the moment we can only do line-level log with parent
3887 * rewriting by performing this expensive pre-filtering step.
3888 * If parent rewriting is not requested, then we rather
3889 * perform the line-level log filtering during the regular
3890 * history traversal.
3892 line_log_filter(revs);
3893 if (revs->simplify_merges)
3894 simplify_merges(revs);
3895 if (revs->children.name)
3896 set_children(revs);
3898 return 0;
3901 static enum rewrite_result rewrite_one_1(struct rev_info *revs,
3902 struct commit **pp,
3903 struct prio_queue *queue)
3905 for (;;) {
3906 struct commit *p = *pp;
3907 if (!revs->limited)
3908 if (process_parents(revs, p, NULL, queue) < 0)
3909 return rewrite_one_error;
3910 if (p->object.flags & UNINTERESTING)
3911 return rewrite_one_ok;
3912 if (!(p->object.flags & TREESAME))
3913 return rewrite_one_ok;
3914 if (!p->parents)
3915 return rewrite_one_noparents;
3916 if (!(p = one_relevant_parent(revs, p->parents)))
3917 return rewrite_one_ok;
3918 *pp = p;
3922 static void merge_queue_into_list(struct prio_queue *q, struct commit_list **list)
3924 while (q->nr) {
3925 struct commit *item = prio_queue_peek(q);
3926 struct commit_list *p = *list;
3928 if (p && p->item->date >= item->date)
3929 list = &p->next;
3930 else {
3931 p = commit_list_insert(item, list);
3932 list = &p->next; /* skip newly added item */
3933 prio_queue_get(q); /* pop item */
3938 static enum rewrite_result rewrite_one(struct rev_info *revs, struct commit **pp)
3940 struct prio_queue queue = { compare_commits_by_commit_date };
3941 enum rewrite_result ret = rewrite_one_1(revs, pp, &queue);
3942 merge_queue_into_list(&queue, &revs->commits);
3943 clear_prio_queue(&queue);
3944 return ret;
3947 int rewrite_parents(struct rev_info *revs, struct commit *commit,
3948 rewrite_parent_fn_t rewrite_parent)
3950 struct commit_list **pp = &commit->parents;
3951 while (*pp) {
3952 struct commit_list *parent = *pp;
3953 switch (rewrite_parent(revs, &parent->item)) {
3954 case rewrite_one_ok:
3955 break;
3956 case rewrite_one_noparents:
3957 *pp = parent->next;
3958 continue;
3959 case rewrite_one_error:
3960 return -1;
3962 pp = &parent->next;
3964 remove_duplicate_parents(revs, commit);
3965 return 0;
3968 static int commit_match(struct commit *commit, struct rev_info *opt)
3970 int retval;
3971 const char *encoding;
3972 const char *message;
3973 struct strbuf buf = STRBUF_INIT;
3975 if (!opt->grep_filter.pattern_list && !opt->grep_filter.header_list)
3976 return 1;
3978 /* Prepend "fake" headers as needed */
3979 if (opt->grep_filter.use_reflog_filter) {
3980 strbuf_addstr(&buf, "reflog ");
3981 get_reflog_message(&buf, opt->reflog_info);
3982 strbuf_addch(&buf, '\n');
3986 * We grep in the user's output encoding, under the assumption that it
3987 * is the encoding they are most likely to write their grep pattern
3988 * for. In addition, it means we will match the "notes" encoding below,
3989 * so we will not end up with a buffer that has two different encodings
3990 * in it.
3992 encoding = get_log_output_encoding();
3993 message = repo_logmsg_reencode(the_repository, commit, NULL, encoding);
3995 /* Copy the commit to temporary if we are using "fake" headers */
3996 if (buf.len)
3997 strbuf_addstr(&buf, message);
3999 if (opt->grep_filter.header_list && opt->mailmap) {
4000 const char *commit_headers[] = { "author ", "committer ", NULL };
4002 if (!buf.len)
4003 strbuf_addstr(&buf, message);
4005 apply_mailmap_to_header(&buf, commit_headers, opt->mailmap);
4008 /* Append "fake" message parts as needed */
4009 if (opt->show_notes) {
4010 if (!buf.len)
4011 strbuf_addstr(&buf, message);
4012 format_display_notes(&commit->object.oid, &buf, encoding, 1);
4016 * Find either in the original commit message, or in the temporary.
4017 * Note that we cast away the constness of "message" here. It is
4018 * const because it may come from the cached commit buffer. That's OK,
4019 * because we know that it is modifiable heap memory, and that while
4020 * grep_buffer may modify it for speed, it will restore any
4021 * changes before returning.
4023 if (buf.len)
4024 retval = grep_buffer(&opt->grep_filter, buf.buf, buf.len);
4025 else
4026 retval = grep_buffer(&opt->grep_filter,
4027 (char *)message, strlen(message));
4028 strbuf_release(&buf);
4029 repo_unuse_commit_buffer(the_repository, commit, message);
4030 return retval;
4033 static inline int want_ancestry(const struct rev_info *revs)
4035 return (revs->rewrite_parents || revs->children.name);
4039 * Return a timestamp to be used for --since/--until comparisons for this
4040 * commit, based on the revision options.
4042 static timestamp_t comparison_date(const struct rev_info *revs,
4043 struct commit *commit)
4045 return revs->reflog_info ?
4046 get_reflog_timestamp(revs->reflog_info) :
4047 commit->date;
4050 enum commit_action get_commit_action(struct rev_info *revs, struct commit *commit)
4052 if (commit->object.flags & SHOWN)
4053 return commit_ignore;
4054 if (revs->unpacked && has_object_pack(&commit->object.oid))
4055 return commit_ignore;
4056 if (revs->no_kept_objects) {
4057 if (has_object_kept_pack(&commit->object.oid,
4058 revs->keep_pack_cache_flags))
4059 return commit_ignore;
4061 if (commit->object.flags & UNINTERESTING)
4062 return commit_ignore;
4063 if (revs->line_level_traverse && !want_ancestry(revs)) {
4065 * In case of line-level log with parent rewriting
4066 * prepare_revision_walk() already took care of all line-level
4067 * log filtering, and there is nothing left to do here.
4069 * If parent rewriting was not requested, then this is the
4070 * place to perform the line-level log filtering. Notably,
4071 * this check, though expensive, must come before the other,
4072 * cheaper filtering conditions, because the tracked line
4073 * ranges must be adjusted even when the commit will end up
4074 * being ignored based on other conditions.
4076 if (!line_log_process_ranges_arbitrary_commit(revs, commit))
4077 return commit_ignore;
4079 if (revs->min_age != -1 &&
4080 comparison_date(revs, commit) > revs->min_age)
4081 return commit_ignore;
4082 if (revs->max_age_as_filter != -1 &&
4083 comparison_date(revs, commit) < revs->max_age_as_filter)
4084 return commit_ignore;
4085 if (revs->min_parents || (revs->max_parents >= 0)) {
4086 int n = commit_list_count(commit->parents);
4087 if ((n < revs->min_parents) ||
4088 ((revs->max_parents >= 0) && (n > revs->max_parents)))
4089 return commit_ignore;
4091 if (!commit_match(commit, revs))
4092 return commit_ignore;
4093 if (revs->prune && revs->dense) {
4094 /* Commit without changes? */
4095 if (commit->object.flags & TREESAME) {
4096 int n;
4097 struct commit_list *p;
4098 /* drop merges unless we want parenthood */
4099 if (!want_ancestry(revs))
4100 return commit_ignore;
4102 if (revs->show_pulls && (commit->object.flags & PULL_MERGE))
4103 return commit_show;
4106 * If we want ancestry, then need to keep any merges
4107 * between relevant commits to tie together topology.
4108 * For consistency with TREESAME and simplification
4109 * use "relevant" here rather than just INTERESTING,
4110 * to treat bottom commit(s) as part of the topology.
4112 for (n = 0, p = commit->parents; p; p = p->next)
4113 if (relevant_commit(p->item))
4114 if (++n >= 2)
4115 return commit_show;
4116 return commit_ignore;
4119 return commit_show;
4122 define_commit_slab(saved_parents, struct commit_list *);
4124 #define EMPTY_PARENT_LIST ((struct commit_list *)-1)
4127 * You may only call save_parents() once per commit (this is checked
4128 * for non-root commits).
4130 static void save_parents(struct rev_info *revs, struct commit *commit)
4132 struct commit_list **pp;
4134 if (!revs->saved_parents_slab) {
4135 revs->saved_parents_slab = xmalloc(sizeof(struct saved_parents));
4136 init_saved_parents(revs->saved_parents_slab);
4139 pp = saved_parents_at(revs->saved_parents_slab, commit);
4142 * When walking with reflogs, we may visit the same commit
4143 * several times: once for each appearance in the reflog.
4145 * In this case, save_parents() will be called multiple times.
4146 * We want to keep only the first set of parents. We need to
4147 * store a sentinel value for an empty (i.e., NULL) parent
4148 * list to distinguish it from a not-yet-saved list, however.
4150 if (*pp)
4151 return;
4152 if (commit->parents)
4153 *pp = copy_commit_list(commit->parents);
4154 else
4155 *pp = EMPTY_PARENT_LIST;
4158 static void free_saved_parents(struct rev_info *revs)
4160 if (revs->saved_parents_slab)
4161 clear_saved_parents(revs->saved_parents_slab);
4164 struct commit_list *get_saved_parents(struct rev_info *revs, const struct commit *commit)
4166 struct commit_list *parents;
4168 if (!revs->saved_parents_slab)
4169 return commit->parents;
4171 parents = *saved_parents_at(revs->saved_parents_slab, commit);
4172 if (parents == EMPTY_PARENT_LIST)
4173 return NULL;
4174 return parents;
4177 enum commit_action simplify_commit(struct rev_info *revs, struct commit *commit)
4179 enum commit_action action = get_commit_action(revs, commit);
4181 if (action == commit_show &&
4182 revs->prune && revs->dense && want_ancestry(revs)) {
4184 * --full-diff on simplified parents is no good: it
4185 * will show spurious changes from the commits that
4186 * were elided. So we save the parents on the side
4187 * when --full-diff is in effect.
4189 if (revs->full_diff)
4190 save_parents(revs, commit);
4191 if (rewrite_parents(revs, commit, rewrite_one) < 0)
4192 return commit_error;
4194 return action;
4197 static void track_linear(struct rev_info *revs, struct commit *commit)
4199 if (revs->track_first_time) {
4200 revs->linear = 1;
4201 revs->track_first_time = 0;
4202 } else {
4203 struct commit_list *p;
4204 for (p = revs->previous_parents; p; p = p->next)
4205 if (p->item == NULL || /* first commit */
4206 oideq(&p->item->object.oid, &commit->object.oid))
4207 break;
4208 revs->linear = p != NULL;
4210 if (revs->reverse) {
4211 if (revs->linear)
4212 commit->object.flags |= TRACK_LINEAR;
4214 free_commit_list(revs->previous_parents);
4215 revs->previous_parents = copy_commit_list(commit->parents);
4218 static struct commit *get_revision_1(struct rev_info *revs)
4220 while (1) {
4221 struct commit *commit;
4223 if (revs->reflog_info)
4224 commit = next_reflog_entry(revs->reflog_info);
4225 else if (revs->topo_walk_info)
4226 commit = next_topo_commit(revs);
4227 else
4228 commit = pop_commit(&revs->commits);
4230 if (!commit)
4231 return NULL;
4233 if (revs->reflog_info)
4234 commit->object.flags &= ~(ADDED | SEEN | SHOWN);
4237 * If we haven't done the list limiting, we need to look at
4238 * the parents here. We also need to do the date-based limiting
4239 * that we'd otherwise have done in limit_list().
4241 if (!revs->limited) {
4242 if (revs->max_age != -1 &&
4243 comparison_date(revs, commit) < revs->max_age)
4244 continue;
4246 if (revs->reflog_info)
4247 try_to_simplify_commit(revs, commit);
4248 else if (revs->topo_walk_info)
4249 expand_topo_walk(revs, commit);
4250 else if (process_parents(revs, commit, &revs->commits, NULL) < 0) {
4251 if (!revs->ignore_missing_links)
4252 die("Failed to traverse parents of commit %s",
4253 oid_to_hex(&commit->object.oid));
4257 switch (simplify_commit(revs, commit)) {
4258 case commit_ignore:
4259 continue;
4260 case commit_error:
4261 die("Failed to simplify parents of commit %s",
4262 oid_to_hex(&commit->object.oid));
4263 default:
4264 if (revs->track_linear)
4265 track_linear(revs, commit);
4266 return commit;
4272 * Return true for entries that have not yet been shown. (This is an
4273 * object_array_each_func_t.)
4275 static int entry_unshown(struct object_array_entry *entry, void *cb_data UNUSED)
4277 return !(entry->item->flags & SHOWN);
4281 * If array is on the verge of a realloc, garbage-collect any entries
4282 * that have already been shown to try to free up some space.
4284 static void gc_boundary(struct object_array *array)
4286 if (array->nr == array->alloc)
4287 object_array_filter(array, entry_unshown, NULL);
4290 static void create_boundary_commit_list(struct rev_info *revs)
4292 unsigned i;
4293 struct commit *c;
4294 struct object_array *array = &revs->boundary_commits;
4295 struct object_array_entry *objects = array->objects;
4298 * If revs->commits is non-NULL at this point, an error occurred in
4299 * get_revision_1(). Ignore the error and continue printing the
4300 * boundary commits anyway. (This is what the code has always
4301 * done.)
4303 free_commit_list(revs->commits);
4304 revs->commits = NULL;
4307 * Put all of the actual boundary commits from revs->boundary_commits
4308 * into revs->commits
4310 for (i = 0; i < array->nr; i++) {
4311 c = (struct commit *)(objects[i].item);
4312 if (!c)
4313 continue;
4314 if (!(c->object.flags & CHILD_SHOWN))
4315 continue;
4316 if (c->object.flags & (SHOWN | BOUNDARY))
4317 continue;
4318 c->object.flags |= BOUNDARY;
4319 commit_list_insert(c, &revs->commits);
4323 * If revs->topo_order is set, sort the boundary commits
4324 * in topological order
4326 sort_in_topological_order(&revs->commits, revs->sort_order);
4329 static struct commit *get_revision_internal(struct rev_info *revs)
4331 struct commit *c = NULL;
4332 struct commit_list *l;
4334 if (revs->boundary == 2) {
4336 * All of the normal commits have already been returned,
4337 * and we are now returning boundary commits.
4338 * create_boundary_commit_list() has populated
4339 * revs->commits with the remaining commits to return.
4341 c = pop_commit(&revs->commits);
4342 if (c)
4343 c->object.flags |= SHOWN;
4344 return c;
4348 * If our max_count counter has reached zero, then we are done. We
4349 * don't simply return NULL because we still might need to show
4350 * boundary commits. But we want to avoid calling get_revision_1, which
4351 * might do a considerable amount of work finding the next commit only
4352 * for us to throw it away.
4354 * If it is non-zero, then either we don't have a max_count at all
4355 * (-1), or it is still counting, in which case we decrement.
4357 if (revs->max_count) {
4358 c = get_revision_1(revs);
4359 if (c) {
4360 while (revs->skip_count > 0) {
4361 revs->skip_count--;
4362 c = get_revision_1(revs);
4363 if (!c)
4364 break;
4368 if (revs->max_count > 0)
4369 revs->max_count--;
4372 if (c)
4373 c->object.flags |= SHOWN;
4375 if (!revs->boundary)
4376 return c;
4378 if (!c) {
4380 * get_revision_1() runs out the commits, and
4381 * we are done computing the boundaries.
4382 * switch to boundary commits output mode.
4384 revs->boundary = 2;
4387 * Update revs->commits to contain the list of
4388 * boundary commits.
4390 create_boundary_commit_list(revs);
4392 return get_revision_internal(revs);
4396 * boundary commits are the commits that are parents of the
4397 * ones we got from get_revision_1() but they themselves are
4398 * not returned from get_revision_1(). Before returning
4399 * 'c', we need to mark its parents that they could be boundaries.
4402 for (l = c->parents; l; l = l->next) {
4403 struct object *p;
4404 p = &(l->item->object);
4405 if (p->flags & (CHILD_SHOWN | SHOWN))
4406 continue;
4407 p->flags |= CHILD_SHOWN;
4408 gc_boundary(&revs->boundary_commits);
4409 add_object_array(p, NULL, &revs->boundary_commits);
4412 return c;
4415 struct commit *get_revision(struct rev_info *revs)
4417 struct commit *c;
4418 struct commit_list *reversed;
4420 if (revs->reverse) {
4421 reversed = NULL;
4422 while ((c = get_revision_internal(revs)))
4423 commit_list_insert(c, &reversed);
4424 revs->commits = reversed;
4425 revs->reverse = 0;
4426 revs->reverse_output_stage = 1;
4429 if (revs->reverse_output_stage) {
4430 c = pop_commit(&revs->commits);
4431 if (revs->track_linear)
4432 revs->linear = !!(c && c->object.flags & TRACK_LINEAR);
4433 return c;
4436 c = get_revision_internal(revs);
4437 if (c && revs->graph)
4438 graph_update(revs->graph, c);
4439 if (!c) {
4440 free_saved_parents(revs);
4441 free_commit_list(revs->previous_parents);
4442 revs->previous_parents = NULL;
4444 return c;
4447 const char *get_revision_mark(const struct rev_info *revs, const struct commit *commit)
4449 if (commit->object.flags & BOUNDARY)
4450 return "-";
4451 else if (commit->object.flags & UNINTERESTING)
4452 return "^";
4453 else if (commit->object.flags & PATCHSAME)
4454 return "=";
4455 else if (!revs || revs->left_right) {
4456 if (commit->object.flags & SYMMETRIC_LEFT)
4457 return "<";
4458 else
4459 return ">";
4460 } else if (revs->graph)
4461 return "*";
4462 else if (revs->cherry_mark)
4463 return "+";
4464 return "";
4467 void put_revision_mark(const struct rev_info *revs, const struct commit *commit)
4469 const char *mark = get_revision_mark(revs, commit);
4470 if (!strlen(mark))
4471 return;
4472 fputs(mark, stdout);
4473 putchar(' ');