From 183df63940bf92ea626af64d0057165b8aad24f6 Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Sat, 15 Apr 2006 01:59:40 -0700 Subject: [PATCH] Revert all the rev-list option parsing changes. Signed-off-by: Junio C Hamano --- diff-tree.c | 92 +++++++++++++++------------- git.c | 84 ++++++++++++++++++++----- log-tree.c | 60 ++++++++++++++++-- log-tree.h | 22 +++++-- rev-list.c | 6 +- revision.c | 173 +++++++++++----------------------------------------- revision.h | 21 +------ 7 files changed, 229 insertions(+), 229 deletions(-) diff --git a/diff-tree.c b/diff-tree.c index 979f792b6..2b79dd0a6 100644 --- a/diff-tree.c +++ b/diff-tree.c @@ -3,7 +3,7 @@ #include "commit.h" #include "log-tree.h" -static struct rev_info log_tree_opt; +static struct log_tree_opt log_tree_opt; static int diff_tree_commit_sha1(const unsigned char *sha1) { @@ -62,19 +62,47 @@ int main(int argc, const char **argv) { int nr_sha1; char line[1000]; - struct object *tree1, *tree2; - static struct rev_info *opt = &log_tree_opt; - struct object_list *list; + unsigned char sha1[2][20]; + const char *prefix = setup_git_directory(); + static struct log_tree_opt *opt = &log_tree_opt; int read_stdin = 0; git_config(git_diff_config); nr_sha1 = 0; - opt->abbrev = 0; - argc = setup_revisions(argc, argv, opt, NULL); + init_log_tree_opt(opt); - while (--argc > 0) { - const char *arg = *++argv; + for (;;) { + int opt_cnt; + const char *arg; + argv++; + argc--; + arg = *argv; + if (!arg) + break; + + if (*arg != '-') { + if (nr_sha1 < 2 && !get_sha1(arg, sha1[nr_sha1])) { + nr_sha1++; + continue; + } + break; + } + + opt_cnt = log_tree_opt_parse(opt, argv, argc); + if (opt_cnt < 0) + usage(diff_tree_usage); + else if (opt_cnt) { + argv += opt_cnt - 1; + argc -= opt_cnt - 1; + continue; + } + + if (!strcmp(arg, "--")) { + argv++; + argc--; + break; + } if (!strcmp(arg, "--stdin")) { read_stdin = 1; continue; @@ -82,36 +110,18 @@ int main(int argc, const char **argv) usage(diff_tree_usage); } - /* - * NOTE! "setup_revisions()" will have inserted the revisions - * it parsed in reverse order. So if you do - * - * git-diff-tree a b - * - * the commit list will be "b" -> "a" -> NULL, so we reverse - * the order of the objects if the first one is not marked - * UNINTERESTING. - */ - nr_sha1 = 0; - list = opt->pending_objects; - if (list) { - nr_sha1++; - tree1 = list->item; - list = list->next; - if (list) { - nr_sha1++; - tree2 = tree1; - tree1 = list->item; - if (list->next) - usage(diff_tree_usage); - /* Switch them around if the second one was uninteresting.. */ - if (tree2->flags & UNINTERESTING) { - struct object *tmp = tree2; - tree2 = tree1; - tree1 = tmp; - } - } - } + if (opt->combine_merges) + opt->ignore_merges = 0; + + /* We can only do dense combined merges with diff output */ + if (opt->dense_combined_merges) + opt->diffopt.output_format = DIFF_FORMAT_PATCH; + + if (opt->diffopt.output_format == DIFF_FORMAT_PATCH) + opt->diffopt.recursive = 1; + + diff_tree_setup_paths(get_pathspec(prefix, argv), opt); + diff_setup_done(&opt->diffopt); switch (nr_sha1) { case 0: @@ -119,12 +129,10 @@ int main(int argc, const char **argv) usage(diff_tree_usage); break; case 1: - diff_tree_commit_sha1(tree1->sha1); + diff_tree_commit_sha1(sha1[0]); break; case 2: - diff_tree_sha1(tree1->sha1, - tree2->sha1, - "", &opt->diffopt); + diff_tree_sha1(sha1[0], sha1[1], "", &opt->diffopt); log_tree_diff_flush(opt); break; } diff --git a/git.c b/git.c index 9d885569d..78ed403ed 100644 --- a/git.c +++ b/git.c @@ -283,26 +283,82 @@ static int cmd_log(int argc, const char **argv, char **envp) struct rev_info rev; struct commit *commit; char *buf = xmalloc(LOGSIZE); + static enum cmit_fmt commit_format = CMIT_FMT_DEFAULT; + int abbrev = DEFAULT_ABBREV; + int abbrev_commit = 0; const char *commit_prefix = "commit "; + struct log_tree_opt opt; int shown = 0; + int do_diff = 0; + int full_diff = 0; - rev.abbrev = DEFAULT_ABBREV; + init_log_tree_opt(&opt); argc = setup_revisions(argc, argv, &rev, "HEAD"); - if (argc > 1) - die("unrecognized argument: %s", argv[1]); + while (1 < argc) { + const char *arg = argv[1]; + if (!strncmp(arg, "--pretty", 8)) { + commit_format = get_commit_format(arg + 8); + if (commit_format == CMIT_FMT_ONELINE) + commit_prefix = ""; + } + else if (!strcmp(arg, "--no-abbrev")) { + abbrev = 0; + } + else if (!strcmp(arg, "--abbrev")) { + abbrev = DEFAULT_ABBREV; + } + else if (!strcmp(arg, "--abbrev-commit")) { + abbrev_commit = 1; + } + else if (!strncmp(arg, "--abbrev=", 9)) { + abbrev = strtoul(arg + 9, NULL, 10); + if (abbrev && abbrev < MINIMUM_ABBREV) + abbrev = MINIMUM_ABBREV; + else if (40 < abbrev) + abbrev = 40; + } + else if (!strcmp(arg, "--full-diff")) { + do_diff = 1; + full_diff = 1; + } + else { + int cnt = log_tree_opt_parse(&opt, argv+1, argc-1); + if (0 < cnt) { + do_diff = 1; + argv += cnt; + argc -= cnt; + continue; + } + die("unrecognized argument: %s", arg); + } - rev.no_commit_id = 1; - if (rev.commit_format == CMIT_FMT_ONELINE) - commit_prefix = ""; + argc--; argv++; + } + + if (do_diff) { + opt.diffopt.abbrev = abbrev; + opt.verbose_header = 0; + opt.always_show_header = 0; + opt.no_commit_id = 1; + if (opt.combine_merges) + opt.ignore_merges = 0; + if (opt.dense_combined_merges) + opt.diffopt.output_format = DIFF_FORMAT_PATCH; + if (opt.diffopt.output_format == DIFF_FORMAT_PATCH) + opt.diffopt.recursive = 1; + if (!full_diff && rev.prune_data) + diff_tree_setup_paths(rev.prune_data, &opt.diffopt); + diff_setup_done(&opt.diffopt); + } prepare_revision_walk(&rev); setup_pager(); while ((commit = get_revision(&rev)) != NULL) { - if (shown && rev.diff && rev.commit_format != CMIT_FMT_ONELINE) + if (shown && do_diff && commit_format != CMIT_FMT_ONELINE) putchar('\n'); fputs(commit_prefix, stdout); - if (rev.abbrev_commit && rev.abbrev) - fputs(find_unique_abbrev(commit->object.sha1, rev.abbrev), + if (abbrev_commit && abbrev) + fputs(find_unique_abbrev(commit->object.sha1, abbrev), stdout); else fputs(sha1_to_hex(commit->object.sha1), stdout); @@ -325,15 +381,15 @@ static int cmd_log(int argc, const char **argv, char **envp) parents = parents->next) parents->item->object.flags &= ~TMP_MARK; } - if (rev.commit_format == CMIT_FMT_ONELINE) + if (commit_format == CMIT_FMT_ONELINE) putchar(' '); else putchar('\n'); - pretty_print_commit(rev.commit_format, commit, ~0, buf, - LOGSIZE, rev.abbrev); + pretty_print_commit(commit_format, commit, ~0, buf, + LOGSIZE, abbrev); printf("%s\n", buf); - if (rev.diff) - log_tree_commit(&rev, commit); + if (do_diff) + log_tree_commit(&opt, commit); shown = 1; free(commit->buffer); commit->buffer = NULL; diff --git a/log-tree.c b/log-tree.c index 04a68e0f5..3d404824a 100644 --- a/log-tree.c +++ b/log-tree.c @@ -3,7 +3,57 @@ #include "commit.h" #include "log-tree.h" -int log_tree_diff_flush(struct rev_info *opt) +void init_log_tree_opt(struct log_tree_opt *opt) +{ + memset(opt, 0, sizeof *opt); + opt->ignore_merges = 1; + opt->header_prefix = ""; + opt->commit_format = CMIT_FMT_RAW; + diff_setup(&opt->diffopt); +} + +int log_tree_opt_parse(struct log_tree_opt *opt, const char **av, int ac) +{ + const char *arg; + int cnt = diff_opt_parse(&opt->diffopt, av, ac); + if (0 < cnt) + return cnt; + arg = *av; + if (!strcmp(arg, "-r")) + opt->diffopt.recursive = 1; + else if (!strcmp(arg, "-t")) { + opt->diffopt.recursive = 1; + opt->diffopt.tree_in_recursive = 1; + } + else if (!strcmp(arg, "-m")) + opt->ignore_merges = 0; + else if (!strcmp(arg, "-c")) + opt->combine_merges = 1; + else if (!strcmp(arg, "--cc")) { + opt->dense_combined_merges = 1; + opt->combine_merges = 1; + } + else if (!strcmp(arg, "-v")) { + opt->verbose_header = 1; + opt->header_prefix = "diff-tree "; + } + else if (!strncmp(arg, "--pretty", 8)) { + opt->verbose_header = 1; + opt->header_prefix = "diff-tree "; + opt->commit_format = get_commit_format(arg+8); + } + else if (!strcmp(arg, "--root")) + opt->show_root_diff = 1; + else if (!strcmp(arg, "--no-commit-id")) + opt->no_commit_id = 1; + else if (!strcmp(arg, "--always")) + opt->always_show_header = 1; + else + return 0; + return 1; +} + +int log_tree_diff_flush(struct log_tree_opt *opt) { diffcore_std(&opt->diffopt); if (diff_queue_is_empty()) { @@ -23,7 +73,7 @@ int log_tree_diff_flush(struct rev_info *opt) return 1; } -static int diff_root_tree(struct rev_info *opt, +static int diff_root_tree(struct log_tree_opt *opt, const unsigned char *new, const char *base) { int retval; @@ -43,7 +93,7 @@ static int diff_root_tree(struct rev_info *opt, return retval; } -static const char *generate_header(struct rev_info *opt, +static const char *generate_header(struct log_tree_opt *opt, const unsigned char *commit_sha1, const unsigned char *parent_sha1, const struct commit *commit) @@ -79,7 +129,7 @@ static const char *generate_header(struct rev_info *opt, return this_header; } -static int do_diff_combined(struct rev_info *opt, struct commit *commit) +static int do_diff_combined(struct log_tree_opt *opt, struct commit *commit) { unsigned const char *sha1 = commit->object.sha1; @@ -92,7 +142,7 @@ static int do_diff_combined(struct rev_info *opt, struct commit *commit) return 0; } -int log_tree_commit(struct rev_info *opt, struct commit *commit) +int log_tree_commit(struct log_tree_opt *opt, struct commit *commit) { struct commit_list *parents; unsigned const char *sha1 = commit->object.sha1; diff --git a/log-tree.h b/log-tree.h index 91a909be7..da166c6f2 100644 --- a/log-tree.h +++ b/log-tree.h @@ -1,11 +1,23 @@ #ifndef LOG_TREE_H #define LOG_TREE_H -#include "revision.h" +struct log_tree_opt { + struct diff_options diffopt; + int show_root_diff; + int no_commit_id; + int verbose_header; + int ignore_merges; + int combine_merges; + int dense_combined_merges; + int always_show_header; + const char *header_prefix; + const char *header; + enum cmit_fmt commit_format; +}; -void init_log_tree_opt(struct rev_info *); -int log_tree_diff_flush(struct rev_info *); -int log_tree_commit(struct rev_info *, struct commit *); -int log_tree_opt_parse(struct rev_info *, const char **, int); +void init_log_tree_opt(struct log_tree_opt *); +int log_tree_diff_flush(struct log_tree_opt *); +int log_tree_commit(struct log_tree_opt *, struct commit *); +int log_tree_opt_parse(struct log_tree_opt *, const char **, int); #endif diff --git a/rev-list.c b/rev-list.c index 0de21810c..963707a49 100644 --- a/rev-list.c +++ b/rev-list.c @@ -365,10 +365,8 @@ int main(int argc, const char **argv) list = revs.commits; - if ((!list && - (!(revs.tag_objects||revs.tree_objects||revs.blob_objects) && - !revs.pending_objects)) || - revs.diff) + if (!list && + (!(revs.tag_objects||revs.tree_objects||revs.blob_objects) && !revs.pending_objects)) usage(rev_list_usage); save_commit_buffer = verbose_header; diff --git a/revision.c b/revision.c index bdf8005ae..0505f3f45 100644 --- a/revision.c +++ b/revision.c @@ -116,27 +116,21 @@ static void add_pending_object(struct rev_info *revs, struct object *obj, const add_object(obj, &revs->pending_objects, NULL, name); } -static struct object *get_reference(struct rev_info *revs, const char *name, const unsigned char *sha1, unsigned int flags) +static struct commit *get_commit_reference(struct rev_info *revs, const char *name, const unsigned char *sha1, unsigned int flags) { struct object *object; object = parse_object(sha1); if (!object) die("bad object %s", name); - object->flags |= flags; - return object; -} - -static struct commit *handle_commit(struct rev_info *revs, struct object *object, const char *name) -{ - unsigned long flags = object->flags; /* * Tag object? Look what it points to.. */ while (object->type == tag_type) { struct tag *tag = (struct tag *) object; - if (revs->tag_objects && !(flags & UNINTERESTING)) + object->flags |= flags; + if (revs->tag_objects && !(object->flags & UNINTERESTING)) add_pending_object(revs, object, tag->tag); object = parse_object(tag->tagged->sha1); if (!object) @@ -149,6 +143,7 @@ static struct commit *handle_commit(struct rev_info *revs, struct object *object */ if (object->type == commit_type) { struct commit *commit = (struct commit *)object; + object->flags |= flags; if (parse_commit(commit) < 0) die("unable to parse commit %s", name); if (flags & UNINTERESTING) { @@ -246,7 +241,7 @@ int rev_compare_tree(struct rev_info *revs, struct tree *t1, struct tree *t2) return REV_TREE_DIFFERENT; tree_difference = REV_TREE_SAME; if (diff_tree_sha1(t1->object.sha1, t2->object.sha1, "", - &revs->pruning) < 0) + &revs->diffopt) < 0) return REV_TREE_DIFFERENT; return tree_difference; } @@ -269,7 +264,7 @@ int rev_same_tree_as_empty(struct rev_info *revs, struct tree *t1) empty.size = 0; tree_difference = 0; - retval = diff_tree(&empty, &real, "", &revs->pruning); + retval = diff_tree(&empty, &real, "", &revs->diffopt); free(tree); return retval >= 0 && !tree_difference; @@ -456,13 +451,21 @@ static void limit_list(struct rev_info *revs) revs->commits = newlist; } +static void add_one_commit(struct commit *commit, struct rev_info *revs) +{ + if (!commit || (commit->object.flags & SEEN)) + return; + commit->object.flags |= SEEN; + commit_list_insert(commit, &revs->commits); +} + static int all_flags; static struct rev_info *all_revs; static int handle_one_ref(const char *path, const unsigned char *sha1) { - struct object *object = get_reference(all_revs, path, sha1, all_flags); - add_pending_object(all_revs, object, ""); + struct commit *commit = get_commit_reference(all_revs, path, sha1, all_flags); + add_one_commit(commit, all_revs); return 0; } @@ -475,15 +478,10 @@ static void handle_all(struct rev_info *revs, unsigned flags) void init_revisions(struct rev_info *revs) { - unsigned abbrev = revs->abbrev; - memset(revs, 0, sizeof(*revs)); - - revs->abbrev = abbrev; - revs->ignore_merges = 1; - revs->pruning.recursive = 1; - revs->pruning.add_remove = file_add_remove; - revs->pruning.change = file_change; + revs->diffopt.recursive = 1; + revs->diffopt.add_remove = file_add_remove; + revs->diffopt.change = file_change; revs->lifo = 1; revs->dense = 1; revs->prefix = setup_git_directory(); @@ -496,11 +494,6 @@ void init_revisions(struct rev_info *revs) revs->topo_setter = topo_sort_default_setter; revs->topo_getter = topo_sort_default_getter; - - revs->header_prefix = ""; - revs->commit_format = CMIT_FMT_DEFAULT; - - diff_setup(&revs->diffopt); } /* @@ -533,14 +526,13 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch flags = 0; for (i = 1; i < argc; i++) { - struct object *object; + struct commit *commit; const char *arg = argv[i]; unsigned char sha1[20]; char *dotdot; int local_flags; if (*arg == '-') { - int opts; if (!strncmp(arg, "--max-count=", 12)) { revs->max_count = atoi(arg + 12); continue; @@ -648,78 +640,6 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch revs->unpacked = 1; continue; } - if (!strcmp(arg, "-r")) { - revs->diff = 1; - revs->diffopt.recursive = 1; - continue; - } - if (!strcmp(arg, "-t")) { - revs->diff = 1; - revs->diffopt.recursive = 1; - revs->diffopt.tree_in_recursive = 1; - continue; - } - if (!strcmp(arg, "-m")) { - revs->ignore_merges = 0; - continue; - } - if (!strcmp(arg, "-c")) { - revs->diff = 1; - revs->combine_merges = 1; - continue; - } - if (!strcmp(arg, "--cc")) { - revs->diff = 1; - revs->dense_combined_merges = 1; - revs->combine_merges = 1; - continue; - } - if (!strcmp(arg, "-v")) { - revs->verbose_header = 1; - revs->header_prefix = "diff-tree "; - continue; - } - if (!strncmp(arg, "--pretty", 8)) { - revs->verbose_header = 1; - revs->header_prefix = "diff-tree "; - revs->commit_format = get_commit_format(arg+8); - continue; - } - if (!strcmp(arg, "--root")) { - revs->show_root_diff = 1; - continue; - } - if (!strcmp(arg, "--no-commit-id")) { - revs->no_commit_id = 1; - continue; - } - if (!strcmp(arg, "--always")) { - revs->always_show_header = 1; - continue; - } - if (!strcmp(arg, "--no-abbrev")) { - revs->abbrev = 0; - continue; - } - if (!strcmp(arg, "--abbrev")) { - revs->abbrev = DEFAULT_ABBREV; - continue; - } - if (!strcmp(arg, "--abbrev-commit")) { - revs->abbrev_commit = 1; - continue; - } - if (!strcmp(arg, "--full-diff")) { - revs->diff = 1; - revs->full_diff = 1; - continue; - } - opts = diff_opt_parse(&revs->diffopt, argv+i, argc-i); - if (opts > 0) { - revs->diff = 1; - i += opts - 1; - continue; - } *unrecognized++ = arg; left++; continue; @@ -736,15 +656,15 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch this = "HEAD"; if (!get_sha1(this, from_sha1) && !get_sha1(next, sha1)) { - struct object *exclude; - struct object *include; + struct commit *exclude; + struct commit *include; - exclude = get_reference(revs, this, from_sha1, flags ^ UNINTERESTING); - include = get_reference(revs, next, sha1, flags); + exclude = get_commit_reference(revs, this, from_sha1, flags ^ UNINTERESTING); + include = get_commit_reference(revs, next, sha1, flags); if (!exclude || !include) die("Invalid revision range %s..%s", arg, next); - add_pending_object(revs, exclude, this); - add_pending_object(revs, include, next); + add_one_commit(exclude, revs); + add_one_commit(include, revs); continue; } *dotdot = '.'; @@ -769,57 +689,32 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch revs->prune_data = get_pathspec(revs->prefix, argv + i); break; } - object = get_reference(revs, arg, sha1, flags ^ local_flags); - add_pending_object(revs, object, arg); + commit = get_commit_reference(revs, arg, sha1, flags ^ local_flags); + add_one_commit(commit, revs); } - if (def && !revs->pending_objects) { + if (def && !revs->commits) { unsigned char sha1[20]; - struct object *object; + struct commit *commit; if (get_sha1(def, sha1) < 0) die("bad default revision '%s'", def); - object = get_reference(revs, def, sha1, 0); - add_pending_object(revs, object, def); + commit = get_commit_reference(revs, def, sha1, 0); + add_one_commit(commit, revs); } if (revs->topo_order || revs->unpacked) revs->limited = 1; if (revs->prune_data) { - diff_tree_setup_paths(revs->prune_data, &revs->pruning); + diff_tree_setup_paths(revs->prune_data, &revs->diffopt); revs->prune_fn = try_to_simplify_commit; - if (!revs->full_diff) - diff_tree_setup_paths(revs->prune_data, &revs->diffopt); - } - if (revs->combine_merges) { - revs->ignore_merges = 0; - if (revs->dense_combined_merges) - revs->diffopt.output_format = DIFF_FORMAT_PATCH; } - if (revs->diffopt.output_format == DIFF_FORMAT_PATCH) - revs->diffopt.recursive = 1; - revs->diffopt.abbrev = revs->abbrev; - diff_setup_done(&revs->diffopt); return left; } void prepare_revision_walk(struct rev_info *revs) { - struct object_list *list; - - list = revs->pending_objects; - revs->pending_objects = NULL; - while (list) { - struct commit *commit = handle_commit(revs, list->item, list->name); - if (commit) { - if (!(commit->object.flags & SEEN)) { - commit->object.flags |= SEEN; - insert_by_date(commit, &revs->commits); - } - } - list = list->next; - } - + sort_by_date(&revs->commits); if (revs->limited) limit_list(revs); if (revs->topo_order) diff --git a/revision.h b/revision.h index 6eaa9048a..8970b57e3 100644 --- a/revision.h +++ b/revision.h @@ -38,32 +38,13 @@ struct rev_info { boundary:1, parents:1; - /* Diff flags */ - unsigned int diff:1, - full_diff:1, - show_root_diff:1, - no_commit_id:1, - verbose_header:1, - ignore_merges:1, - combine_merges:1, - dense_combined_merges:1, - always_show_header:1; - - /* Format info */ - unsigned int abbrev_commit:1; - unsigned int abbrev; - enum cmit_fmt commit_format; - const char *header_prefix; - const char *header; - /* special limits */ int max_count; unsigned long max_age; unsigned long min_age; - /* diff info for patches and for paths limiting */ + /* paths limiting */ struct diff_options diffopt; - struct diff_options pruning; topo_sort_set_fn_t topo_setter; topo_sort_get_fn_t topo_getter; -- 2.30.2