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 commit
->object
.flags
|= UNINTERESTING
;
88 * Normally we haven't parsed the parent
89 * yet, so we won't have a parent of a parent
90 * here. However, it may turn out that we've
91 * reached this commit some other way (where it
92 * wasn't uninteresting), in which case we need
93 * to mark its parents recursively too..
96 mark_parents_uninteresting(commit
);
99 * A missing commit is ok iff its parent is marked
102 * We just mark such a thing parsed, so that when
103 * it is popped next time around, we won't be trying
104 * to parse it and get an error.
106 if (!has_sha1_file(commit
->object
.sha1
))
107 commit
->object
.parsed
= 1;
108 parents
= parents
->next
;
112 static void add_pending_object(struct rev_info
*revs
, struct object
*obj
, const char *name
)
114 add_object(obj
, &revs
->pending_objects
, NULL
, name
);
117 static struct commit
*get_commit_reference(struct rev_info
*revs
, const char *name
, const unsigned char *sha1
, unsigned int flags
)
119 struct object
*object
;
121 object
= parse_object(sha1
);
123 die("bad object %s", name
);
126 * Tag object? Look what it points to..
128 while (object
->type
== tag_type
) {
129 struct tag
*tag
= (struct tag
*) object
;
130 object
->flags
|= flags
;
131 if (revs
->tag_objects
&& !(object
->flags
& UNINTERESTING
))
132 add_pending_object(revs
, object
, tag
->tag
);
133 object
= parse_object(tag
->tagged
->sha1
);
135 die("bad object %s", sha1_to_hex(tag
->tagged
->sha1
));
139 * Commit object? Just return it, we'll do all the complex
142 if (object
->type
== commit_type
) {
143 struct commit
*commit
= (struct commit
*)object
;
144 object
->flags
|= flags
;
145 if (parse_commit(commit
) < 0)
146 die("unable to parse commit %s", name
);
147 if (flags
& UNINTERESTING
) {
148 mark_parents_uninteresting(commit
);
155 * Tree object? Either mark it uniniteresting, or add it
156 * to the list of objects to look at later..
158 if (object
->type
== tree_type
) {
159 struct tree
*tree
= (struct tree
*)object
;
160 if (!revs
->tree_objects
)
162 if (flags
& UNINTERESTING
) {
163 mark_tree_uninteresting(tree
);
166 add_pending_object(revs
, object
, "");
171 * Blob object? You know the drill by now..
173 if (object
->type
== blob_type
) {
174 struct blob
*blob
= (struct blob
*)object
;
175 if (!revs
->blob_objects
)
177 if (flags
& UNINTERESTING
) {
178 mark_blob_uninteresting(blob
);
181 add_pending_object(revs
, object
, "");
184 die("%s is unknown object", name
);
187 static int everybody_uninteresting(struct commit_list
*orig
)
189 struct commit_list
*list
= orig
;
191 struct commit
*commit
= list
->item
;
193 if (commit
->object
.flags
& UNINTERESTING
)
202 #define TREE_DIFFERENT 2
203 static int tree_difference
= TREE_SAME
;
205 static void file_add_remove(struct diff_options
*options
,
206 int addremove
, unsigned mode
,
207 const unsigned char *sha1
,
208 const char *base
, const char *path
)
210 int diff
= TREE_DIFFERENT
;
213 * Is it an add of a new file? It means that
214 * the old tree didn't have it at all, so we
215 * will turn "TREE_SAME" -> "TREE_NEW", but
216 * leave any "TREE_DIFFERENT" alone (and if
217 * it already was "TREE_NEW", we'll keep it
218 * "TREE_NEW" of course).
220 if (addremove
== '+') {
221 diff
= tree_difference
;
222 if (diff
!= TREE_SAME
)
226 tree_difference
= diff
;
229 static void file_change(struct diff_options
*options
,
230 unsigned old_mode
, unsigned new_mode
,
231 const unsigned char *old_sha1
,
232 const unsigned char *new_sha1
,
233 const char *base
, const char *path
)
235 tree_difference
= TREE_DIFFERENT
;
238 static struct diff_options diff_opt
= {
240 .add_remove
= file_add_remove
,
241 .change
= file_change
,
244 static int compare_tree(struct tree
*t1
, struct tree
*t2
)
249 return TREE_DIFFERENT
;
250 tree_difference
= TREE_SAME
;
251 if (diff_tree_sha1(t1
->object
.sha1
, t2
->object
.sha1
, "", &diff_opt
) < 0)
252 return TREE_DIFFERENT
;
253 return tree_difference
;
256 static int same_tree_as_empty(struct tree
*t1
)
260 struct tree_desc empty
, real
;
265 tree
= read_object_with_reference(t1
->object
.sha1
, "tree", &real
.size
, NULL
);
274 retval
= diff_tree(&empty
, &real
, "", &diff_opt
);
277 return retval
>= 0 && !tree_difference
;
280 static void try_to_simplify_commit(struct rev_info
*revs
, struct commit
*commit
)
282 struct commit_list
**pp
, *parent
;
287 if (!commit
->parents
) {
288 if (!same_tree_as_empty(commit
->tree
))
289 commit
->object
.flags
|= TREECHANGE
;
293 pp
= &commit
->parents
;
294 while ((parent
= *pp
) != NULL
) {
295 struct commit
*p
= parent
->item
;
297 if (p
->object
.flags
& UNINTERESTING
) {
303 switch (compare_tree(p
->tree
, commit
->tree
)) {
306 commit
->parents
= parent
;
310 if (revs
->remove_empty_trees
&& same_tree_as_empty(p
->tree
)) {
319 die("bad tree compare for commit %s", sha1_to_hex(commit
->object
.sha1
));
321 commit
->object
.flags
|= TREECHANGE
;
324 static void add_parents_to_list(struct rev_info
*revs
, struct commit
*commit
, struct commit_list
**list
)
326 struct commit_list
*parent
= commit
->parents
;
329 * If the commit is uninteresting, don't try to
330 * prune parents - we want the maximal uninteresting
333 * Normally we haven't parsed the parent
334 * yet, so we won't have a parent of a parent
335 * here. However, it may turn out that we've
336 * reached this commit some other way (where it
337 * wasn't uninteresting), in which case we need
338 * to mark its parents recursively too..
340 if (commit
->object
.flags
& UNINTERESTING
) {
342 struct commit
*p
= parent
->item
;
343 parent
= parent
->next
;
345 p
->object
.flags
|= UNINTERESTING
;
347 mark_parents_uninteresting(p
);
348 if (p
->object
.flags
& SEEN
)
350 p
->object
.flags
|= SEEN
;
351 insert_by_date(p
, list
);
357 * Ok, the commit wasn't uninteresting. Try to
358 * simplify the commit history and find the parent
359 * that has no differences in the path set if one exists.
362 try_to_simplify_commit(revs
, commit
);
364 parent
= commit
->parents
;
366 struct commit
*p
= parent
->item
;
368 parent
= parent
->next
;
371 if (p
->object
.flags
& SEEN
)
373 p
->object
.flags
|= SEEN
;
374 insert_by_date(p
, list
);
378 static void limit_list(struct rev_info
*revs
)
380 struct commit_list
*list
= revs
->commits
;
381 struct commit_list
*newlist
= NULL
;
382 struct commit_list
**p
= &newlist
;
385 diff_tree_setup_paths(revs
->paths
);
388 struct commit_list
*entry
= list
;
389 struct commit
*commit
= list
->item
;
390 struct object
*obj
= &commit
->object
;
395 if (revs
->max_age
!= -1 && (commit
->date
< revs
->max_age
))
396 obj
->flags
|= UNINTERESTING
;
397 if (revs
->unpacked
&& has_sha1_pack(obj
->sha1
))
398 obj
->flags
|= UNINTERESTING
;
399 add_parents_to_list(revs
, commit
, &list
);
400 if (obj
->flags
& UNINTERESTING
) {
401 mark_parents_uninteresting(commit
);
402 if (everybody_uninteresting(list
))
406 if (revs
->min_age
!= -1 && (commit
->date
> revs
->min_age
))
408 p
= &commit_list_insert(commit
, p
)->next
;
410 revs
->commits
= newlist
;
413 static void add_one_commit(struct commit
*commit
, struct rev_info
*revs
)
415 if (!commit
|| (commit
->object
.flags
& SEEN
))
417 commit
->object
.flags
|= SEEN
;
418 commit_list_insert(commit
, &revs
->commits
);
421 static int all_flags
;
422 static struct rev_info
*all_revs
;
424 static int handle_one_ref(const char *path
, const unsigned char *sha1
)
426 struct commit
*commit
= get_commit_reference(all_revs
, path
, sha1
, all_flags
);
427 add_one_commit(commit
, all_revs
);
431 static void handle_all(struct rev_info
*revs
, unsigned flags
)
435 for_each_ref(handle_one_ref
);
439 * Parse revision information, filling in the "rev_info" structure,
440 * and removing the used arguments from the argument list.
442 * Returns the number of arguments left that weren't recognized
443 * (which are also moved to the head of the argument list)
445 int setup_revisions(int argc
, const char **argv
, struct rev_info
*revs
, const char *def
)
447 int i
, flags
, seen_dashdash
;
448 const char **unrecognized
= argv
+ 1;
451 memset(revs
, 0, sizeof(*revs
));
454 revs
->prefix
= setup_git_directory();
457 revs
->max_count
= -1;
459 /* First, search for "--" */
461 for (i
= 1; i
< argc
; i
++) {
462 const char *arg
= argv
[i
];
463 if (strcmp(arg
, "--"))
467 revs
->paths
= get_pathspec(revs
->prefix
, argv
+ i
+ 1);
473 for (i
= 1; i
< argc
; i
++) {
474 struct commit
*commit
;
475 const char *arg
= argv
[i
];
476 unsigned char sha1
[20];
481 if (!strncmp(arg
, "--max-count=", 12)) {
482 revs
->max_count
= atoi(arg
+ 12);
485 /* accept -<digit>, like traditilnal "head" */
486 if ((*arg
== '-') && isdigit(arg
[1])) {
487 revs
->max_count
= atoi(arg
+ 1);
490 if (!strcmp(arg
, "-n")) {
492 die("-n requires an argument");
493 revs
->max_count
= atoi(argv
[++i
]);
496 if (!strncmp(arg
,"-n",2)) {
497 revs
->max_count
= atoi(arg
+ 2);
500 if (!strncmp(arg
, "--max-age=", 10)) {
501 revs
->max_age
= atoi(arg
+ 10);
505 if (!strncmp(arg
, "--min-age=", 10)) {
506 revs
->min_age
= atoi(arg
+ 10);
510 if (!strncmp(arg
, "--since=", 8)) {
511 revs
->max_age
= approxidate(arg
+ 8);
515 if (!strncmp(arg
, "--after=", 8)) {
516 revs
->max_age
= approxidate(arg
+ 8);
520 if (!strncmp(arg
, "--before=", 9)) {
521 revs
->min_age
= approxidate(arg
+ 9);
525 if (!strncmp(arg
, "--until=", 8)) {
526 revs
->min_age
= approxidate(arg
+ 8);
530 if (!strcmp(arg
, "--all")) {
531 handle_all(revs
, flags
);
534 if (!strcmp(arg
, "--not")) {
535 flags
^= UNINTERESTING
;
538 if (!strcmp(arg
, "--default")) {
540 die("bad --default argument");
544 if (!strcmp(arg
, "--topo-order")) {
545 revs
->topo_order
= 1;
549 if (!strcmp(arg
, "--date-order")) {
551 revs
->topo_order
= 1;
555 if (!strcmp(arg
, "--dense")) {
559 if (!strcmp(arg
, "--sparse")) {
563 if (!strcmp(arg
, "--remove-empty")) {
564 revs
->remove_empty_trees
= 1;
567 if (!strncmp(arg
, "--no-merges", 11)) {
571 if (!strcmp(arg
, "--objects")) {
572 revs
->tag_objects
= 1;
573 revs
->tree_objects
= 1;
574 revs
->blob_objects
= 1;
577 if (!strcmp(arg
, "--objects-edge")) {
578 revs
->tag_objects
= 1;
579 revs
->tree_objects
= 1;
580 revs
->blob_objects
= 1;
584 if (!strcmp(arg
, "--unpacked")) {
589 *unrecognized
++ = arg
;
593 dotdot
= strstr(arg
, "..");
595 unsigned char from_sha1
[20];
596 char *next
= dotdot
+ 2;
600 if (!get_sha1(arg
, from_sha1
) && !get_sha1(next
, sha1
)) {
601 struct commit
*exclude
;
602 struct commit
*include
;
604 exclude
= get_commit_reference(revs
, arg
, from_sha1
, flags
^ UNINTERESTING
);
605 include
= get_commit_reference(revs
, next
, sha1
, flags
);
606 if (!exclude
|| !include
)
607 die("Invalid revision range %s..%s", arg
, next
);
608 add_one_commit(exclude
, revs
);
609 add_one_commit(include
, revs
);
616 local_flags
= UNINTERESTING
;
619 if (get_sha1(arg
, sha1
) < 0) {
623 if (seen_dashdash
|| local_flags
)
624 die("bad revision '%s'", arg
);
626 /* If we didn't have a "--", all filenames must exist */
627 for (j
= i
; j
< argc
; j
++) {
628 if (lstat(argv
[j
], &st
) < 0)
629 die("'%s': %s", arg
, strerror(errno
));
631 revs
->paths
= get_pathspec(revs
->prefix
, argv
+ i
);
634 commit
= get_commit_reference(revs
, arg
, sha1
, flags
^ local_flags
);
635 add_one_commit(commit
, revs
);
637 if (def
&& !revs
->commits
) {
638 unsigned char sha1
[20];
639 struct commit
*commit
;
640 if (get_sha1(def
, sha1
) < 0)
641 die("bad default revision '%s'", def
);
642 commit
= get_commit_reference(revs
, def
, sha1
, 0);
643 add_one_commit(commit
, revs
);
650 void prepare_revision_walk(struct rev_info
*revs
)
652 sort_by_date(&revs
->commits
);
655 if (revs
->topo_order
)
656 sort_in_topological_order(&revs
->commits
, revs
->lifo
);
659 static int rewrite_one(struct commit
**pp
)
662 struct commit
*p
= *pp
;
663 if (p
->object
.flags
& (TREECHANGE
| UNINTERESTING
))
667 *pp
= p
->parents
->item
;
671 static void rewrite_parents(struct commit
*commit
)
673 struct commit_list
**pp
= &commit
->parents
;
675 struct commit_list
*parent
= *pp
;
676 if (rewrite_one(&parent
->item
) < 0) {
684 struct commit
*get_revision(struct rev_info
*revs
)
686 struct commit_list
*list
= revs
->commits
;
687 struct commit
*commit
;
692 /* Check the max_count ... */
694 switch (revs
->max_count
) {
704 commit
= pop_most_recent_commit(&revs
->commits
, SEEN
);
705 if (commit
->object
.flags
& (UNINTERESTING
|SHOWN
))
707 if (revs
->min_age
!= -1 && (commit
->date
> revs
->min_age
))
709 if (revs
->max_age
!= -1 && (commit
->date
< revs
->max_age
))
711 if (revs
->no_merges
&& commit
->parents
&& commit
->parents
->next
)
713 if (revs
->paths
&& revs
->dense
) {
714 if (!(commit
->object
.flags
& TREECHANGE
))
716 rewrite_parents(commit
);
718 commit
->object
.flags
|= SHOWN
;
720 } while (revs
->commits
);