@matheusbsbs / matheus-bagliano / commits / 183df63940
Fork 0

Revert all the rev-list option parsing changes.

Signed-off-by: Junio C Hamano <junkio@cox.net>

Junio C Hamano committed Apr 15, 2006 at 01:59 UTC 183df63940bf92ea626af64d0057165b8aad24f6
7 files changed +229 -229
diff-tree.c
+50 -42
@@ -3,7 +3,7 @@
3 #include "commit.h"
4 #include "log-tree.h"
5
6 -static struct rev_info log_tree_opt;
6 +static struct log_tree_opt log_tree_opt;
7
8 static int diff_tree_commit_sha1(const unsigned char *sha1)
9 {
@@ -62,19 +62,47 @@ int main(int argc, const char **argv)
62 {
63 int nr_sha1;
64 char line[1000];
65 - struct object *tree1, *tree2;
66 - static struct rev_info *opt = &log_tree_opt;
67 - struct object_list *list;
65 + unsigned char sha1[2][20];
66 + const char *prefix = setup_git_directory();
67 + static struct log_tree_opt *opt = &log_tree_opt;
68 int read_stdin = 0;
69
70 git_config(git_diff_config);
71 nr_sha1 = 0;
72 - opt->abbrev = 0;
73 - argc = setup_revisions(argc, argv, opt, NULL);
72 + init_log_tree_opt(opt);
73
75 - while (--argc > 0) {
76 - const char *arg = *++argv;
74 + for (;;) {
75 + int opt_cnt;
76 + const char *arg;
77
78 + argv++;
79 + argc--;
80 + arg = *argv;
81 + if (!arg)
82 + break;
83 +
84 + if (*arg != '-') {
85 + if (nr_sha1 < 2 && !get_sha1(arg, sha1[nr_sha1])) {
86 + nr_sha1++;
87 + continue;
88 + }
89 + break;
90 + }
91 +
92 + opt_cnt = log_tree_opt_parse(opt, argv, argc);
93 + if (opt_cnt < 0)
94 + usage(diff_tree_usage);
95 + else if (opt_cnt) {
96 + argv += opt_cnt - 1;
97 + argc -= opt_cnt - 1;
98 + continue;
99 + }
100 +
101 + if (!strcmp(arg, "--")) {
102 + argv++;
103 + argc--;
104 + break;
105 + }
106 if (!strcmp(arg, "--stdin")) {
107 read_stdin = 1;
108 continue;
@@ -82,36 +110,18 @@ int main(int argc, const char **argv)
110 usage(diff_tree_usage);
111 }
112
85 - /*
86 - * NOTE! "setup_revisions()" will have inserted the revisions
87 - * it parsed in reverse order. So if you do
88 - *
89 - * git-diff-tree a b
90 - *
91 - * the commit list will be "b" -> "a" -> NULL, so we reverse
92 - * the order of the objects if the first one is not marked
93 - * UNINTERESTING.
94 - */
95 - nr_sha1 = 0;
96 - list = opt->pending_objects;
97 - if (list) {
98 - nr_sha1++;
99 - tree1 = list->item;
100 - list = list->next;
101 - if (list) {
102 - nr_sha1++;
103 - tree2 = tree1;
104 - tree1 = list->item;
105 - if (list->next)
106 - usage(diff_tree_usage);
107 - /* Switch them around if the second one was uninteresting.. */
108 - if (tree2->flags & UNINTERESTING) {
109 - struct object *tmp = tree2;
110 - tree2 = tree1;
111 - tree1 = tmp;
112 - }
113 - }
114 - }
113 + if (opt->combine_merges)
114 + opt->ignore_merges = 0;
115 +
116 + /* We can only do dense combined merges with diff output */
117 + if (opt->dense_combined_merges)
118 + opt->diffopt.output_format = DIFF_FORMAT_PATCH;
119 +
120 + if (opt->diffopt.output_format == DIFF_FORMAT_PATCH)
121 + opt->diffopt.recursive = 1;
122 +
123 + diff_tree_setup_paths(get_pathspec(prefix, argv), opt);
124 + diff_setup_done(&opt->diffopt);
125
126 switch (nr_sha1) {
127 case 0:
@@ -119,12 +129,10 @@ int main(int argc, const char **argv)
129 usage(diff_tree_usage);
130 break;
131 case 1:
122 - diff_tree_commit_sha1(tree1->sha1);
132 + diff_tree_commit_sha1(sha1[0]);
133 break;
134 case 2:
125 - diff_tree_sha1(tree1->sha1,
126 - tree2->sha1,
127 - "", &opt->diffopt);
135 + diff_tree_sha1(sha1[0], sha1[1], "", &opt->diffopt);
136 log_tree_diff_flush(opt);
137 break;
138 }
git.c
+70 -14
@@ -283,26 +283,82 @@ static int cmd_log(int argc, const char **argv, char **envp)
283 struct rev_info rev;
284 struct commit *commit;
285 char *buf = xmalloc(LOGSIZE);
286 + static enum cmit_fmt commit_format = CMIT_FMT_DEFAULT;
287 + int abbrev = DEFAULT_ABBREV;
288 + int abbrev_commit = 0;
289 const char *commit_prefix = "commit ";
290 + struct log_tree_opt opt;
291 int shown = 0;
292 + int do_diff = 0;
293 + int full_diff = 0;
294
289 - rev.abbrev = DEFAULT_ABBREV;
295 + init_log_tree_opt(&opt);
296 argc = setup_revisions(argc, argv, &rev, "HEAD");
291 - if (argc > 1)
292 - die("unrecognized argument: %s", argv[1]);
297 + while (1 < argc) {
298 + const char *arg = argv[1];
299 + if (!strncmp(arg, "--pretty", 8)) {
300 + commit_format = get_commit_format(arg + 8);
301 + if (commit_format == CMIT_FMT_ONELINE)
302 + commit_prefix = "";
303 + }
304 + else if (!strcmp(arg, "--no-abbrev")) {
305 + abbrev = 0;
306 + }
307 + else if (!strcmp(arg, "--abbrev")) {
308 + abbrev = DEFAULT_ABBREV;
309 + }
310 + else if (!strcmp(arg, "--abbrev-commit")) {
311 + abbrev_commit = 1;
312 + }
313 + else if (!strncmp(arg, "--abbrev=", 9)) {
314 + abbrev = strtoul(arg + 9, NULL, 10);
315 + if (abbrev && abbrev < MINIMUM_ABBREV)
316 + abbrev = MINIMUM_ABBREV;
317 + else if (40 < abbrev)
318 + abbrev = 40;
319 + }
320 + else if (!strcmp(arg, "--full-diff")) {
321 + do_diff = 1;
322 + full_diff = 1;
323 + }
324 + else {
325 + int cnt = log_tree_opt_parse(&opt, argv+1, argc-1);
326 + if (0 < cnt) {
327 + do_diff = 1;
328 + argv += cnt;
329 + argc -= cnt;
330 + continue;
331 + }
332 + die("unrecognized argument: %s", arg);
333 + }
334
294 - rev.no_commit_id = 1;
295 - if (rev.commit_format == CMIT_FMT_ONELINE)
296 - commit_prefix = "";
335 + argc--; argv++;
336 + }
337 +
338 + if (do_diff) {
339 + opt.diffopt.abbrev = abbrev;
340 + opt.verbose_header = 0;
341 + opt.always_show_header = 0;
342 + opt.no_commit_id = 1;
343 + if (opt.combine_merges)
344 + opt.ignore_merges = 0;
345 + if (opt.dense_combined_merges)
346 + opt.diffopt.output_format = DIFF_FORMAT_PATCH;
347 + if (opt.diffopt.output_format == DIFF_FORMAT_PATCH)
348 + opt.diffopt.recursive = 1;
349 + if (!full_diff && rev.prune_data)
350 + diff_tree_setup_paths(rev.prune_data, &opt.diffopt);
351 + diff_setup_done(&opt.diffopt);
352 + }
353
354 prepare_revision_walk(&rev);
355 setup_pager();
356 while ((commit = get_revision(&rev)) != NULL) {
301 - if (shown && rev.diff && rev.commit_format != CMIT_FMT_ONELINE)
357 + if (shown && do_diff && commit_format != CMIT_FMT_ONELINE)
358 putchar('\n');
359 fputs(commit_prefix, stdout);
304 - if (rev.abbrev_commit && rev.abbrev)
305 - fputs(find_unique_abbrev(commit->object.sha1, rev.abbrev),
360 + if (abbrev_commit && abbrev)
361 + fputs(find_unique_abbrev(commit->object.sha1, abbrev),
362 stdout);
363 else
364 fputs(sha1_to_hex(commit->object.sha1), stdout);
@@ -325,15 +381,15 @@ static int cmd_log(int argc, const char **argv, char **envp)
381 parents = parents->next)
382 parents->item->object.flags &= ~TMP_MARK;
383 }
328 - if (rev.commit_format == CMIT_FMT_ONELINE)
384 + if (commit_format == CMIT_FMT_ONELINE)
385 putchar(' ');
386 else
387 putchar('\n');
332 - pretty_print_commit(rev.commit_format, commit, ~0, buf,
333 - LOGSIZE, rev.abbrev);
388 + pretty_print_commit(commit_format, commit, ~0, buf,
389 + LOGSIZE, abbrev);
390 printf("%s\n", buf);
335 - if (rev.diff)
336 - log_tree_commit(&rev, commit);
391 + if (do_diff)
392 + log_tree_commit(&opt, commit);
393 shown = 1;
394 free(commit->buffer);
395 commit->buffer = NULL;
log-tree.c
+55 -5
@@ -3,7 +3,57 @@
3 #include "commit.h"
4 #include "log-tree.h"
5
6 -int log_tree_diff_flush(struct rev_info *opt)
6 +void init_log_tree_opt(struct log_tree_opt *opt)
7 +{
8 + memset(opt, 0, sizeof *opt);
9 + opt->ignore_merges = 1;
10 + opt->header_prefix = "";
11 + opt->commit_format = CMIT_FMT_RAW;
12 + diff_setup(&opt->diffopt);
13 +}
14 +
15 +int log_tree_opt_parse(struct log_tree_opt *opt, const char **av, int ac)
16 +{
17 + const char *arg;
18 + int cnt = diff_opt_parse(&opt->diffopt, av, ac);
19 + if (0 < cnt)
20 + return cnt;
21 + arg = *av;
22 + if (!strcmp(arg, "-r"))
23 + opt->diffopt.recursive = 1;
24 + else if (!strcmp(arg, "-t")) {
25 + opt->diffopt.recursive = 1;
26 + opt->diffopt.tree_in_recursive = 1;
27 + }
28 + else if (!strcmp(arg, "-m"))
29 + opt->ignore_merges = 0;
30 + else if (!strcmp(arg, "-c"))
31 + opt->combine_merges = 1;
32 + else if (!strcmp(arg, "--cc")) {
33 + opt->dense_combined_merges = 1;
34 + opt->combine_merges = 1;
35 + }
36 + else if (!strcmp(arg, "-v")) {
37 + opt->verbose_header = 1;
38 + opt->header_prefix = "diff-tree ";
39 + }
40 + else if (!strncmp(arg, "--pretty", 8)) {
41 + opt->verbose_header = 1;
42 + opt->header_prefix = "diff-tree ";
43 + opt->commit_format = get_commit_format(arg+8);
44 + }
45 + else if (!strcmp(arg, "--root"))
46 + opt->show_root_diff = 1;
47 + else if (!strcmp(arg, "--no-commit-id"))
48 + opt->no_commit_id = 1;
49 + else if (!strcmp(arg, "--always"))
50 + opt->always_show_header = 1;
51 + else
52 + return 0;
53 + return 1;
54 +}
55 +
56 +int log_tree_diff_flush(struct log_tree_opt *opt)
57 {
58 diffcore_std(&opt->diffopt);
59 if (diff_queue_is_empty()) {
@@ -23,7 +73,7 @@ int log_tree_diff_flush(struct rev_info *opt)
73 return 1;
74 }
75
26 -static int diff_root_tree(struct rev_info *opt,
76 +static int diff_root_tree(struct log_tree_opt *opt,
77 const unsigned char *new, const char *base)
78 {
79 int retval;
@@ -43,7 +93,7 @@ static int diff_root_tree(struct rev_info *opt,
93 return retval;
94 }
95
46 -static const char *generate_header(struct rev_info *opt,
96 +static const char *generate_header(struct log_tree_opt *opt,
97 const unsigned char *commit_sha1,
98 const unsigned char *parent_sha1,
99 const struct commit *commit)
@@ -79,7 +129,7 @@ static const char *generate_header(struct rev_info *opt,
129 return this_header;
130 }
131
82 -static int do_diff_combined(struct rev_info *opt, struct commit *commit)
132 +static int do_diff_combined(struct log_tree_opt *opt, struct commit *commit)
133 {
134 unsigned const char *sha1 = commit->object.sha1;
135
@@ -92,7 +142,7 @@ static int do_diff_combined(struct rev_info *opt, struct commit *commit)
142 return 0;
143 }
144
95 -int log_tree_commit(struct rev_info *opt, struct commit *commit)
145 +int log_tree_commit(struct log_tree_opt *opt, struct commit *commit)
146 {
147 struct commit_list *parents;
148 unsigned const char *sha1 = commit->object.sha1;
log-tree.h
+17 -5
@@ -1,11 +1,23 @@
1 #ifndef LOG_TREE_H
2 #define LOG_TREE_H
3
4 -#include "revision.h"
4 +struct log_tree_opt {
5 + struct diff_options diffopt;
6 + int show_root_diff;
7 + int no_commit_id;
8 + int verbose_header;
9 + int ignore_merges;
10 + int combine_merges;
11 + int dense_combined_merges;
12 + int always_show_header;
13 + const char *header_prefix;
14 + const char *header;
15 + enum cmit_fmt commit_format;
16 +};
17
6 -void init_log_tree_opt(struct rev_info *);
7 -int log_tree_diff_flush(struct rev_info *);
8 -int log_tree_commit(struct rev_info *, struct commit *);
9 -int log_tree_opt_parse(struct rev_info *, const char **, int);
18 +void init_log_tree_opt(struct log_tree_opt *);
19 +int log_tree_diff_flush(struct log_tree_opt *);
20 +int log_tree_commit(struct log_tree_opt *, struct commit *);
21 +int log_tree_opt_parse(struct log_tree_opt *, const char **, int);
22
23 #endif
rev-list.c
+2 -4
@@ -365,10 +365,8 @@ int main(int argc, const char **argv)
365
366 list = revs.commits;
367
368 - if ((!list &&
369 - (!(revs.tag_objects||revs.tree_objects||revs.blob_objects) &&
370 - !revs.pending_objects)) ||
371 - revs.diff)
368 + if (!list &&
369 + (!(revs.tag_objects||revs.tree_objects||revs.blob_objects) && !revs.pending_objects))
370 usage(rev_list_usage);
371
372 save_commit_buffer = verbose_header;
revision.c
+34 -139
@@ -116,27 +116,21 @@ static void add_pending_object(struct rev_info *revs, struct object *obj, const
116 add_object(obj, &revs->pending_objects, NULL, name);
117 }
118
119 -static struct object *get_reference(struct rev_info *revs, const char *name, const unsigned char *sha1, unsigned int flags)
119 +static struct commit *get_commit_reference(struct rev_info *revs, const char *name, const unsigned char *sha1, unsigned int flags)
120 {
121 struct object *object;
122
123 object = parse_object(sha1);
124 if (!object)
125 die("bad object %s", name);
126 - object->flags |= flags;
127 - return object;
128 -}
129 -
130 -static struct commit *handle_commit(struct rev_info *revs, struct object *object, const char *name)
131 -{
132 - unsigned long flags = object->flags;
126
127 /*
128 * Tag object? Look what it points to..
129 */
130 while (object->type == tag_type) {
131 struct tag *tag = (struct tag *) object;
139 - if (revs->tag_objects && !(flags & UNINTERESTING))
132 + object->flags |= flags;
133 + if (revs->tag_objects && !(object->flags & UNINTERESTING))
134 add_pending_object(revs, object, tag->tag);
135 object = parse_object(tag->tagged->sha1);
136 if (!object)
@@ -149,6 +143,7 @@ static struct commit *handle_commit(struct rev_info *revs, struct object *object
143 */
144 if (object->type == commit_type) {
145 struct commit *commit = (struct commit *)object;
146 + object->flags |= flags;
147 if (parse_commit(commit) < 0)
148 die("unable to parse commit %s", name);
149 if (flags & UNINTERESTING) {
@@ -246,7 +241,7 @@ int rev_compare_tree(struct rev_info *revs, struct tree *t1, struct tree *t2)
241 return REV_TREE_DIFFERENT;
242 tree_difference = REV_TREE_SAME;
243 if (diff_tree_sha1(t1->object.sha1, t2->object.sha1, "",
249 - &revs->pruning) < 0)
244 + &revs->diffopt) < 0)
245 return REV_TREE_DIFFERENT;
246 return tree_difference;
247 }
@@ -269,7 +264,7 @@ int rev_same_tree_as_empty(struct rev_info *revs, struct tree *t1)
264 empty.size = 0;
265
266 tree_difference = 0;
272 - retval = diff_tree(&empty, &real, "", &revs->pruning);
267 + retval = diff_tree(&empty, &real, "", &revs->diffopt);
268 free(tree);
269
270 return retval >= 0 && !tree_difference;
@@ -456,13 +451,21 @@ static void limit_list(struct rev_info *revs)
451 revs->commits = newlist;
452 }
453
454 +static void add_one_commit(struct commit *commit, struct rev_info *revs)
455 +{
456 + if (!commit || (commit->object.flags & SEEN))
457 + return;
458 + commit->object.flags |= SEEN;
459 + commit_list_insert(commit, &revs->commits);
460 +}
461 +
462 static int all_flags;
463 static struct rev_info *all_revs;
464
465 static int handle_one_ref(const char *path, const unsigned char *sha1)
466 {
464 - struct object *object = get_reference(all_revs, path, sha1, all_flags);
465 - add_pending_object(all_revs, object, "");
467 + struct commit *commit = get_commit_reference(all_revs, path, sha1, all_flags);
468 + add_one_commit(commit, all_revs);
469 return 0;
470 }
471
@@ -475,15 +478,10 @@ static void handle_all(struct rev_info *revs, unsigned flags)
478
479 void init_revisions(struct rev_info *revs)
480 {
478 - unsigned abbrev = revs->abbrev;
479 -
481 memset(revs, 0, sizeof(*revs));
481 -
482 - revs->abbrev = abbrev;
483 - revs->ignore_merges = 1;
484 - revs->pruning.recursive = 1;
485 - revs->pruning.add_remove = file_add_remove;
486 - revs->pruning.change = file_change;
482 + revs->diffopt.recursive = 1;
483 + revs->diffopt.add_remove = file_add_remove;
484 + revs->diffopt.change = file_change;
485 revs->lifo = 1;
486 revs->dense = 1;
487 revs->prefix = setup_git_directory();
@@ -496,11 +494,6 @@ void init_revisions(struct rev_info *revs)
494
495 revs->topo_setter = topo_sort_default_setter;
496 revs->topo_getter = topo_sort_default_getter;
499 -
500 - revs->header_prefix = "";
501 - revs->commit_format = CMIT_FMT_DEFAULT;
502 -
503 - diff_setup(&revs->diffopt);
497 }
498
499 /*
@@ -533,14 +526,13 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch
526
527 flags = 0;
528 for (i = 1; i < argc; i++) {
536 - struct object *object;
529 + struct commit *commit;
530 const char *arg = argv[i];
531 unsigned char sha1[20];
532 char *dotdot;
533 int local_flags;
534
535 if (*arg == '-') {
543 - int opts;
536 if (!strncmp(arg, "--max-count=", 12)) {
537 revs->max_count = atoi(arg + 12);
538 continue;
@@ -648,78 +640,6 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch
640 revs->unpacked = 1;
641 continue;
642 }
651 - if (!strcmp(arg, "-r")) {
652 - revs->diff = 1;
653 - revs->diffopt.recursive = 1;
654 - continue;
655 - }
656 - if (!strcmp(arg, "-t")) {
657 - revs->diff = 1;
658 - revs->diffopt.recursive = 1;
659 - revs->diffopt.tree_in_recursive = 1;
660 - continue;
661 - }
662 - if (!strcmp(arg, "-m")) {
663 - revs->ignore_merges = 0;
664 - continue;
665 - }
666 - if (!strcmp(arg, "-c")) {
667 - revs->diff = 1;
668 - revs->combine_merges = 1;
669 - continue;
670 - }
671 - if (!strcmp(arg, "--cc")) {
672 - revs->diff = 1;
673 - revs->dense_combined_merges = 1;
674 - revs->combine_merges = 1;
675 - continue;
676 - }
677 - if (!strcmp(arg, "-v")) {
678 - revs->verbose_header = 1;
679 - revs->header_prefix = "diff-tree ";
680 - continue;
681 - }
682 - if (!strncmp(arg, "--pretty", 8)) {
683 - revs->verbose_header = 1;
684 - revs->header_prefix = "diff-tree ";
685 - revs->commit_format = get_commit_format(arg+8);
686 - continue;
687 - }
688 - if (!strcmp(arg, "--root")) {
689 - revs->show_root_diff = 1;
690 - continue;
691 - }
692 - if (!strcmp(arg, "--no-commit-id")) {
693 - revs->no_commit_id = 1;
694 - continue;
695 - }
696 - if (!strcmp(arg, "--always")) {
697 - revs->always_show_header = 1;
698 - continue;
699 - }
700 - if (!strcmp(arg, "--no-abbrev")) {
701 - revs->abbrev = 0;
702 - continue;
703 - }
704 - if (!strcmp(arg, "--abbrev")) {
705 - revs->abbrev = DEFAULT_ABBREV;
706 - continue;
707 - }
708 - if (!strcmp(arg, "--abbrev-commit")) {
709 - revs->abbrev_commit = 1;
710 - continue;
711 - }
712 - if (!strcmp(arg, "--full-diff")) {
713 - revs->diff = 1;
714 - revs->full_diff = 1;
715 - continue;
716 - }
717 - opts = diff_opt_parse(&revs->diffopt, argv+i, argc-i);
718 - if (opts > 0) {
719 - revs->diff = 1;
720 - i += opts - 1;
721 - continue;
722 - }
643 *unrecognized++ = arg;
644 left++;
645 continue;
@@ -736,15 +656,15 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch
656 this = "HEAD";
657 if (!get_sha1(this, from_sha1) &&
658 !get_sha1(next, sha1)) {
739 - struct object *exclude;
740 - struct object *include;
659 + struct commit *exclude;
660 + struct commit *include;
661
742 - exclude = get_reference(revs, this, from_sha1, flags ^ UNINTERESTING);
743 - include = get_reference(revs, next, sha1, flags);
662 + exclude = get_commit_reference(revs, this, from_sha1, flags ^ UNINTERESTING);
663 + include = get_commit_reference(revs, next, sha1, flags);
664 if (!exclude || !include)
665 die("Invalid revision range %s..%s", arg, next);
746 - add_pending_object(revs, exclude, this);
747 - add_pending_object(revs, include, next);
666 + add_one_commit(exclude, revs);
667 + add_one_commit(include, revs);
668 continue;
669 }
670 *dotdot = '.';
@@ -769,57 +689,32 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch
689 revs->prune_data = get_pathspec(revs->prefix, argv + i);
690 break;
691 }
772 - object = get_reference(revs, arg, sha1, flags ^ local_flags);
773 - add_pending_object(revs, object, arg);
692 + commit = get_commit_reference(revs, arg, sha1, flags ^ local_flags);
693 + add_one_commit(commit, revs);
694 }
775 - if (def && !revs->pending_objects) {
695 + if (def && !revs->commits) {
696 unsigned char sha1[20];
777 - struct object *object;
697 + struct commit *commit;
698 if (get_sha1(def, sha1) < 0)
699 die("bad default revision '%s'", def);
780 - object = get_reference(revs, def, sha1, 0);
781 - add_pending_object(revs, object, def);
700 + commit = get_commit_reference(revs, def, sha1, 0);
701 + add_one_commit(commit, revs);
702 }
703
704 if (revs->topo_order || revs->unpacked)
705 revs->limited = 1;
706
707 if (revs->prune_data) {
788 - diff_tree_setup_paths(revs->prune_data, &revs->pruning);
708 + diff_tree_setup_paths(revs->prune_data, &revs->diffopt);
709 revs->prune_fn = try_to_simplify_commit;
790 - if (!revs->full_diff)
791 - diff_tree_setup_paths(revs->prune_data, &revs->diffopt);
792 - }
793 - if (revs->combine_merges) {
794 - revs->ignore_merges = 0;
795 - if (revs->dense_combined_merges)
796 - revs->diffopt.output_format = DIFF_FORMAT_PATCH;
710 }
798 - if (revs->diffopt.output_format == DIFF_FORMAT_PATCH)
799 - revs->diffopt.recursive = 1;
800 - revs->diffopt.abbrev = revs->abbrev;
801 - diff_setup_done(&revs->diffopt);
711
712 return left;
713 }
714
715 void prepare_revision_walk(struct rev_info *revs)
716 {
808 - struct object_list *list;
809 -
810 - list = revs->pending_objects;
811 - revs->pending_objects = NULL;
812 - while (list) {
813 - struct commit *commit = handle_commit(revs, list->item, list->name);
814 - if (commit) {
815 - if (!(commit->object.flags & SEEN)) {
816 - commit->object.flags |= SEEN;
817 - insert_by_date(commit, &revs->commits);
818 - }
819 - }
820 - list = list->next;
821 - }
822 -
717 + sort_by_date(&revs->commits);
718 if (revs->limited)
719 limit_list(revs);
720 if (revs->topo_order)
revision.h
+1 -20
@@ -38,32 +38,13 @@ struct rev_info {
38 boundary:1,
39 parents:1;
40
41 - /* Diff flags */
42 - unsigned int diff:1,
43 - full_diff:1,
44 - show_root_diff:1,
45 - no_commit_id:1,
46 - verbose_header:1,
47 - ignore_merges:1,
48 - combine_merges:1,
49 - dense_combined_merges:1,
50 - always_show_header:1;
51 -
52 - /* Format info */
53 - unsigned int abbrev_commit:1;
54 - unsigned int abbrev;
55 - enum cmit_fmt commit_format;
56 - const char *header_prefix;
57 - const char *header;
58 -
41 /* special limits */
42 int max_count;
43 unsigned long max_age;
44 unsigned long min_age;
45
64 - /* diff info for patches and for paths limiting */
46 + /* paths limiting */
47 struct diff_options diffopt;
66 - struct diff_options pruning;
48
49 topo_sort_set_fn_t topo_setter;
50 topo_sort_get_fn_t topo_getter;