10 static char *path_name(struct name_path
*path
, const char *name
)
14 int nlen
= strlen(name
);
17 for (p
= path
; p
; p
= p
->up
) {
19 len
+= p
->elem_len
+ 1;
22 m
= n
+ len
- (nlen
+ 1);
24 for (p
= path
; p
; p
= p
->up
) {
27 memcpy(m
, p
->elem
, p
->elem_len
);
34 struct object_list
**add_object(struct object
*obj
,
35 struct object_list
**p
,
36 struct name_path
*path
,
39 struct object_list
*entry
= xmalloc(sizeof(*entry
));
42 entry
->name
= path_name(path
, name
);
47 static void mark_blob_uninteresting(struct blob
*blob
)
49 if (blob
->object
.flags
& UNINTERESTING
)
51 blob
->object
.flags
|= UNINTERESTING
;
54 void mark_tree_uninteresting(struct tree
*tree
)
56 struct object
*obj
= &tree
->object
;
57 struct tree_entry_list
*entry
;
59 if (obj
->flags
& UNINTERESTING
)
61 obj
->flags
|= UNINTERESTING
;
62 if (!has_sha1_file(obj
->sha1
))
64 if (parse_tree(tree
) < 0)
65 die("bad tree %s", sha1_to_hex(obj
->sha1
));
66 entry
= tree
->entries
;
69 struct tree_entry_list
*next
= entry
->next
;
71 mark_tree_uninteresting(entry
->item
.tree
);
73 mark_blob_uninteresting(entry
->item
.blob
);
79 void mark_parents_uninteresting(struct commit
*commit
)
81 struct commit_list
*parents
= commit
->parents
;
84 struct commit
*commit
= parents
->item
;
85 if (!(commit
->object
.flags
& UNINTERESTING
)) {
86 commit
->object
.flags
|= UNINTERESTING
;
89 * Normally we haven't parsed the parent
90 * yet, so we won't have a parent of a parent
91 * here. However, it may turn out that we've
92 * reached this commit some other way (where it
93 * wasn't uninteresting), in which case we need
94 * to mark its parents recursively too..
97 mark_parents_uninteresting(commit
);
101 * A missing commit is ok iff its parent is marked
104 * We just mark such a thing parsed, so that when
105 * it is popped next time around, we won't be trying
106 * to parse it and get an error.
108 if (!has_sha1_file(commit
->object
.sha1
))
109 commit
->object
.parsed
= 1;
110 parents
= parents
->next
;
114 static void add_pending_object(struct rev_info
*revs
, struct object
*obj
, const char *name
)
116 add_object(obj
, &revs
->pending_objects
, NULL
, name
);
119 static struct object
*get_reference(struct rev_info
*revs
, const char *name
, const unsigned char *sha1
, unsigned int flags
)
121 struct object
*object
;
123 object
= parse_object(sha1
);
125 die("bad object %s", name
);
126 object
->flags
|= flags
;
130 static struct commit
*handle_commit(struct rev_info
*revs
, struct object
*object
, const char *name
)
132 unsigned long flags
= object
->flags
;
135 * Tag object? Look what it points to..
137 while (object
->type
== tag_type
) {
138 struct tag
*tag
= (struct tag
*) object
;
139 if (revs
->tag_objects
&& !(flags
& UNINTERESTING
))
140 add_pending_object(revs
, object
, tag
->tag
);
141 object
= parse_object(tag
->tagged
->sha1
);
143 die("bad object %s", sha1_to_hex(tag
->tagged
->sha1
));
147 * Commit object? Just return it, we'll do all the complex
150 if (object
->type
== commit_type
) {
151 struct commit
*commit
= (struct commit
*)object
;
152 if (parse_commit(commit
) < 0)
153 die("unable to parse commit %s", name
);
154 if (flags
& UNINTERESTING
) {
155 mark_parents_uninteresting(commit
);
162 * Tree object? Either mark it uniniteresting, or add it
163 * to the list of objects to look at later..
165 if (object
->type
== tree_type
) {
166 struct tree
*tree
= (struct tree
*)object
;
167 if (!revs
->tree_objects
)
169 if (flags
& UNINTERESTING
) {
170 mark_tree_uninteresting(tree
);
173 add_pending_object(revs
, object
, "");
178 * Blob object? You know the drill by now..
180 if (object
->type
== blob_type
) {
181 struct blob
*blob
= (struct blob
*)object
;
182 if (!revs
->blob_objects
)
184 if (flags
& UNINTERESTING
) {
185 mark_blob_uninteresting(blob
);
188 add_pending_object(revs
, object
, "");
191 die("%s is unknown object", name
);
194 static int everybody_uninteresting(struct commit_list
*orig
)
196 struct commit_list
*list
= orig
;
198 struct commit
*commit
= list
->item
;
200 if (commit
->object
.flags
& UNINTERESTING
)
207 static int tree_difference
= REV_TREE_SAME
;
209 static void file_add_remove(struct diff_options
*options
,
210 int addremove
, unsigned mode
,
211 const unsigned char *sha1
,
212 const char *base
, const char *path
)
214 int diff
= REV_TREE_DIFFERENT
;
217 * Is it an add of a new file? It means that the old tree
218 * didn't have it at all, so we will turn "REV_TREE_SAME" ->
219 * "REV_TREE_NEW", but leave any "REV_TREE_DIFFERENT" alone
220 * (and if it already was "REV_TREE_NEW", we'll keep it
221 * "REV_TREE_NEW" of course).
223 if (addremove
== '+') {
224 diff
= tree_difference
;
225 if (diff
!= REV_TREE_SAME
)
229 tree_difference
= diff
;
232 static void file_change(struct diff_options
*options
,
233 unsigned old_mode
, unsigned new_mode
,
234 const unsigned char *old_sha1
,
235 const unsigned char *new_sha1
,
236 const char *base
, const char *path
)
238 tree_difference
= REV_TREE_DIFFERENT
;
241 int rev_compare_tree(struct rev_info
*revs
, struct tree
*t1
, struct tree
*t2
)
246 return REV_TREE_DIFFERENT
;
247 tree_difference
= REV_TREE_SAME
;
248 if (diff_tree_sha1(t1
->object
.sha1
, t2
->object
.sha1
, "",
250 return REV_TREE_DIFFERENT
;
251 return tree_difference
;
254 int rev_same_tree_as_empty(struct rev_info
*revs
, struct tree
*t1
)
258 struct tree_desc empty
, real
;
263 tree
= read_object_with_reference(t1
->object
.sha1
, tree_type
, &real
.size
, NULL
);
272 retval
= diff_tree(&empty
, &real
, "", &revs
->pruning
);
275 return retval
>= 0 && !tree_difference
;
278 static void try_to_simplify_commit(struct rev_info
*revs
, struct commit
*commit
)
280 struct commit_list
**pp
, *parent
;
281 int tree_changed
= 0;
286 if (!commit
->parents
) {
287 if (!rev_same_tree_as_empty(revs
, commit
->tree
))
288 commit
->object
.flags
|= TREECHANGE
;
292 pp
= &commit
->parents
;
293 while ((parent
= *pp
) != NULL
) {
294 struct commit
*p
= parent
->item
;
297 switch (rev_compare_tree(revs
, p
->tree
, commit
->tree
)) {
299 if (p
->object
.flags
& UNINTERESTING
) {
300 /* Even if a merge with an uninteresting
301 * side branch brought the entire change
302 * we are interested in, we do not want
303 * to lose the other branches of this
304 * merge, so we just keep going.
310 commit
->parents
= parent
;
314 if (revs
->remove_empty_trees
&&
315 rev_same_tree_as_empty(revs
, p
->tree
)) {
316 /* We are adding all the specified
317 * paths from this parent, so the
318 * history beyond this parent is not
319 * interesting. Remove its parents
320 * (they are grandparents for us).
321 * IOW, we pretend this parent is a
328 case REV_TREE_DIFFERENT
:
333 die("bad tree compare for commit %s", sha1_to_hex(commit
->object
.sha1
));
336 commit
->object
.flags
|= TREECHANGE
;
339 static void add_parents_to_list(struct rev_info
*revs
, struct commit
*commit
, struct commit_list
**list
)
341 struct commit_list
*parent
= commit
->parents
;
343 if (commit
->object
.flags
& ADDED
)
345 commit
->object
.flags
|= ADDED
;
348 * If the commit is uninteresting, don't try to
349 * prune parents - we want the maximal uninteresting
352 * Normally we haven't parsed the parent
353 * yet, so we won't have a parent of a parent
354 * here. However, it may turn out that we've
355 * reached this commit some other way (where it
356 * wasn't uninteresting), in which case we need
357 * to mark its parents recursively too..
359 if (commit
->object
.flags
& UNINTERESTING
) {
361 struct commit
*p
= parent
->item
;
362 parent
= parent
->next
;
364 p
->object
.flags
|= UNINTERESTING
;
366 mark_parents_uninteresting(p
);
367 if (p
->object
.flags
& SEEN
)
369 p
->object
.flags
|= SEEN
;
370 insert_by_date(p
, list
);
376 * Ok, the commit wasn't uninteresting. Try to
377 * simplify the commit history and find the parent
378 * that has no differences in the path set if one exists.
381 revs
->prune_fn(revs
, commit
);
383 parent
= commit
->parents
;
385 struct commit
*p
= parent
->item
;
387 parent
= parent
->next
;
390 if (p
->object
.flags
& SEEN
)
392 p
->object
.flags
|= SEEN
;
393 insert_by_date(p
, list
);
397 static void limit_list(struct rev_info
*revs
)
399 struct commit_list
*list
= revs
->commits
;
400 struct commit_list
*newlist
= NULL
;
401 struct commit_list
**p
= &newlist
;
404 struct commit_list
*entry
= list
;
405 struct commit
*commit
= list
->item
;
406 struct object
*obj
= &commit
->object
;
411 if (revs
->max_age
!= -1 && (commit
->date
< revs
->max_age
))
412 obj
->flags
|= UNINTERESTING
;
413 if (revs
->unpacked
&& has_sha1_pack(obj
->sha1
))
414 obj
->flags
|= UNINTERESTING
;
415 add_parents_to_list(revs
, commit
, &list
);
416 if (obj
->flags
& UNINTERESTING
) {
417 mark_parents_uninteresting(commit
);
418 if (everybody_uninteresting(list
))
422 if (revs
->min_age
!= -1 && (commit
->date
> revs
->min_age
))
424 p
= &commit_list_insert(commit
, p
)->next
;
426 if (revs
->boundary
) {
427 /* mark the ones that are on the result list first */
428 for (list
= newlist
; list
; list
= list
->next
) {
429 struct commit
*commit
= list
->item
;
430 commit
->object
.flags
|= TMP_MARK
;
432 for (list
= newlist
; list
; list
= list
->next
) {
433 struct commit
*commit
= list
->item
;
434 struct object
*obj
= &commit
->object
;
435 struct commit_list
*parent
;
436 if (obj
->flags
& UNINTERESTING
)
438 for (parent
= commit
->parents
;
440 parent
= parent
->next
) {
441 struct commit
*pcommit
= parent
->item
;
442 if (!(pcommit
->object
.flags
& UNINTERESTING
))
444 pcommit
->object
.flags
|= BOUNDARY
;
445 if (pcommit
->object
.flags
& TMP_MARK
)
447 pcommit
->object
.flags
|= TMP_MARK
;
448 p
= &commit_list_insert(pcommit
, p
)->next
;
451 for (list
= newlist
; list
; list
= list
->next
) {
452 struct commit
*commit
= list
->item
;
453 commit
->object
.flags
&= ~TMP_MARK
;
456 revs
->commits
= newlist
;
459 static int all_flags
;
460 static struct rev_info
*all_revs
;
462 static int handle_one_ref(const char *path
, const unsigned char *sha1
)
464 struct object
*object
= get_reference(all_revs
, path
, sha1
, all_flags
);
465 add_pending_object(all_revs
, object
, "");
469 static void handle_all(struct rev_info
*revs
, unsigned flags
)
473 for_each_ref(handle_one_ref
);
476 void init_revisions(struct rev_info
*revs
)
478 memset(revs
, 0, sizeof(*revs
));
480 revs
->abbrev
= DEFAULT_ABBREV
;
481 revs
->ignore_merges
= 1;
482 revs
->pruning
.recursive
= 1;
483 revs
->pruning
.add_remove
= file_add_remove
;
484 revs
->pruning
.change
= file_change
;
487 revs
->prefix
= setup_git_directory();
490 revs
->max_count
= -1;
492 revs
->prune_fn
= NULL
;
493 revs
->prune_data
= NULL
;
495 revs
->topo_setter
= topo_sort_default_setter
;
496 revs
->topo_getter
= topo_sort_default_getter
;
498 revs
->header_prefix
= "";
499 revs
->commit_format
= CMIT_FMT_DEFAULT
;
501 diff_setup(&revs
->diffopt
);
505 * Parse revision information, filling in the "rev_info" structure,
506 * and removing the used arguments from the argument list.
508 * Returns the number of arguments left that weren't recognized
509 * (which are also moved to the head of the argument list)
511 int setup_revisions(int argc
, const char **argv
, struct rev_info
*revs
, const char *def
)
513 int i
, flags
, seen_dashdash
;
514 const char **unrecognized
= argv
+ 1;
517 /* First, search for "--" */
519 for (i
= 1; i
< argc
; i
++) {
520 const char *arg
= argv
[i
];
521 if (strcmp(arg
, "--"))
525 revs
->prune_data
= get_pathspec(revs
->prefix
, argv
+ i
+ 1);
531 for (i
= 1; i
< argc
; i
++) {
532 struct object
*object
;
533 const char *arg
= argv
[i
];
534 unsigned char sha1
[20];
540 if (!strncmp(arg
, "--max-count=", 12)) {
541 revs
->max_count
= atoi(arg
+ 12);
544 /* accept -<digit>, like traditilnal "head" */
545 if ((*arg
== '-') && isdigit(arg
[1])) {
546 revs
->max_count
= atoi(arg
+ 1);
549 if (!strcmp(arg
, "-n")) {
551 die("-n requires an argument");
552 revs
->max_count
= atoi(argv
[++i
]);
555 if (!strncmp(arg
,"-n",2)) {
556 revs
->max_count
= atoi(arg
+ 2);
559 if (!strncmp(arg
, "--max-age=", 10)) {
560 revs
->max_age
= atoi(arg
+ 10);
563 if (!strncmp(arg
, "--since=", 8)) {
564 revs
->max_age
= approxidate(arg
+ 8);
567 if (!strncmp(arg
, "--after=", 8)) {
568 revs
->max_age
= approxidate(arg
+ 8);
571 if (!strncmp(arg
, "--min-age=", 10)) {
572 revs
->min_age
= atoi(arg
+ 10);
575 if (!strncmp(arg
, "--before=", 9)) {
576 revs
->min_age
= approxidate(arg
+ 9);
579 if (!strncmp(arg
, "--until=", 8)) {
580 revs
->min_age
= approxidate(arg
+ 8);
583 if (!strcmp(arg
, "--all")) {
584 handle_all(revs
, flags
);
587 if (!strcmp(arg
, "--not")) {
588 flags
^= UNINTERESTING
;
591 if (!strcmp(arg
, "--default")) {
593 die("bad --default argument");
597 if (!strcmp(arg
, "--topo-order")) {
598 revs
->topo_order
= 1;
601 if (!strcmp(arg
, "--date-order")) {
603 revs
->topo_order
= 1;
606 if (!strcmp(arg
, "--parents")) {
610 if (!strcmp(arg
, "--dense")) {
614 if (!strcmp(arg
, "--sparse")) {
618 if (!strcmp(arg
, "--remove-empty")) {
619 revs
->remove_empty_trees
= 1;
622 if (!strcmp(arg
, "--no-merges")) {
626 if (!strcmp(arg
, "--boundary")) {
630 if (!strcmp(arg
, "--objects")) {
631 revs
->tag_objects
= 1;
632 revs
->tree_objects
= 1;
633 revs
->blob_objects
= 1;
636 if (!strcmp(arg
, "--objects-edge")) {
637 revs
->tag_objects
= 1;
638 revs
->tree_objects
= 1;
639 revs
->blob_objects
= 1;
643 if (!strcmp(arg
, "--unpacked")) {
647 if (!strcmp(arg
, "-r")) {
649 revs
->diffopt
.recursive
= 1;
652 if (!strcmp(arg
, "-t")) {
654 revs
->diffopt
.recursive
= 1;
655 revs
->diffopt
.tree_in_recursive
= 1;
658 if (!strcmp(arg
, "-m")) {
659 revs
->ignore_merges
= 0;
662 if (!strcmp(arg
, "-c")) {
664 revs
->combine_merges
= 1;
667 if (!strcmp(arg
, "--cc")) {
669 revs
->dense_combined_merges
= 1;
670 revs
->combine_merges
= 1;
673 if (!strcmp(arg
, "-v")) {
674 revs
->verbose_header
= 1;
675 revs
->header_prefix
= "diff-tree ";
678 if (!strncmp(arg
, "--pretty", 8)) {
679 revs
->verbose_header
= 1;
680 revs
->header_prefix
= "diff-tree ";
681 revs
->commit_format
= get_commit_format(arg
+8);
684 if (!strcmp(arg
, "--root")) {
685 revs
->show_root_diff
= 1;
688 if (!strcmp(arg
, "--no-commit-id")) {
689 revs
->no_commit_id
= 1;
692 if (!strcmp(arg
, "--always")) {
693 revs
->always_show_header
= 1;
696 if (!strcmp(arg
, "--no-abbrev")) {
700 if (!strcmp(arg
, "--abbrev")) {
701 revs
->abbrev
= DEFAULT_ABBREV
;
704 if (!strcmp(arg
, "--abbrev-commit")) {
705 revs
->abbrev_commit
= 1;
708 if (!strcmp(arg
, "--full-diff")) {
713 opts
= diff_opt_parse(&revs
->diffopt
, argv
+i
, argc
-i
);
719 *unrecognized
++ = arg
;
723 dotdot
= strstr(arg
, "..");
725 unsigned char from_sha1
[20];
726 const char *next
= dotdot
+ 2;
727 const char *this = arg
;
733 if (!get_sha1(this, from_sha1
) &&
734 !get_sha1(next
, sha1
)) {
735 struct object
*exclude
;
736 struct object
*include
;
738 exclude
= get_reference(revs
, this, from_sha1
, flags
^ UNINTERESTING
);
739 include
= get_reference(revs
, next
, sha1
, flags
);
740 if (!exclude
|| !include
)
741 die("Invalid revision range %s..%s", arg
, next
);
742 add_pending_object(revs
, exclude
, this);
743 add_pending_object(revs
, include
, next
);
750 local_flags
= UNINTERESTING
;
753 if (get_sha1(arg
, sha1
) < 0) {
757 if (seen_dashdash
|| local_flags
)
758 die("bad revision '%s'", arg
);
760 /* If we didn't have a "--", all filenames must exist */
761 for (j
= i
; j
< argc
; j
++) {
762 if (lstat(argv
[j
], &st
) < 0)
763 die("'%s': %s", argv
[j
], strerror(errno
));
765 revs
->prune_data
= get_pathspec(revs
->prefix
, argv
+ i
);
768 object
= get_reference(revs
, arg
, sha1
, flags
^ local_flags
);
769 add_pending_object(revs
, object
, arg
);
771 if (def
&& !revs
->pending_objects
) {
772 unsigned char sha1
[20];
773 struct object
*object
;
774 if (get_sha1(def
, sha1
) < 0)
775 die("bad default revision '%s'", def
);
776 object
= get_reference(revs
, def
, sha1
, 0);
777 add_pending_object(revs
, object
, def
);
780 if (revs
->topo_order
|| revs
->unpacked
)
783 if (revs
->prune_data
) {
784 diff_tree_setup_paths(revs
->prune_data
, &revs
->pruning
);
785 revs
->prune_fn
= try_to_simplify_commit
;
786 if (!revs
->full_diff
)
787 diff_tree_setup_paths(revs
->prune_data
, &revs
->diffopt
);
789 if (revs
->combine_merges
) {
790 revs
->ignore_merges
= 0;
791 if (revs
->dense_combined_merges
)
792 revs
->diffopt
.output_format
= DIFF_FORMAT_PATCH
;
794 if (revs
->diffopt
.output_format
== DIFF_FORMAT_PATCH
)
795 revs
->diffopt
.recursive
= 1;
796 revs
->diffopt
.abbrev
= revs
->abbrev
;
797 diff_setup_done(&revs
->diffopt
);
802 void prepare_revision_walk(struct rev_info
*revs
)
804 struct object_list
*list
;
806 list
= revs
->pending_objects
;
807 revs
->pending_objects
= NULL
;
809 struct commit
*commit
= handle_commit(revs
, list
->item
, list
->name
);
811 if (!(commit
->object
.flags
& SEEN
)) {
812 commit
->object
.flags
|= SEEN
;
813 insert_by_date(commit
, &revs
->commits
);
821 if (revs
->topo_order
)
822 sort_in_topological_order_fn(&revs
->commits
, revs
->lifo
,
827 static int rewrite_one(struct rev_info
*revs
, struct commit
**pp
)
830 struct commit
*p
= *pp
;
832 add_parents_to_list(revs
, p
, &revs
->commits
);
833 if (p
->object
.flags
& (TREECHANGE
| UNINTERESTING
))
837 *pp
= p
->parents
->item
;
841 static void rewrite_parents(struct rev_info
*revs
, struct commit
*commit
)
843 struct commit_list
**pp
= &commit
->parents
;
845 struct commit_list
*parent
= *pp
;
846 if (rewrite_one(revs
, &parent
->item
) < 0) {
854 struct commit
*get_revision(struct rev_info
*revs
)
856 struct commit_list
*list
= revs
->commits
;
861 /* Check the max_count ... */
862 switch (revs
->max_count
) {
872 struct commit
*commit
= revs
->commits
->item
;
874 revs
->commits
= revs
->commits
->next
;
877 * If we haven't done the list limiting, we need to look at
878 * the parents here. We also need to do the date-based limiting
879 * that we'd otherwise have done in limit_list().
881 if (!revs
->limited
) {
882 if ((revs
->unpacked
&&
883 has_sha1_pack(commit
->object
.sha1
)) ||
884 (revs
->max_age
!= -1 &&
885 (commit
->date
< revs
->max_age
)))
887 add_parents_to_list(revs
, commit
, &revs
->commits
);
889 if (commit
->object
.flags
& SHOWN
)
891 if (!(commit
->object
.flags
& BOUNDARY
) &&
892 (commit
->object
.flags
& UNINTERESTING
))
894 if (revs
->min_age
!= -1 && (commit
->date
> revs
->min_age
))
896 if (revs
->no_merges
&&
897 commit
->parents
&& commit
->parents
->next
)
899 if (revs
->prune_fn
&& revs
->dense
) {
900 if (!(commit
->object
.flags
& TREECHANGE
))
903 rewrite_parents(revs
, commit
);
905 commit
->object
.flags
|= SHOWN
;
907 } while (revs
->commits
);