From 5f1c3f07b7f4a8436c7773b8e7a04998190c125e Mon Sep 17 00:00:00 2001 From: Junio C Hamano Date: Sun, 9 Apr 2006 01:11:11 -0700 Subject: [PATCH] log-tree: separate major part of diff-tree. This separates out the part that deals with one-commit diff-tree (and --stdin form) into a separate log-tree module. There are two goals with this. The more important one is to be able to make this part available to "git log --diff", so that we can have a native "git whatchanged" command. Another is to simplify the commit log generation part simpler. Signed-off-by: Junio C Hamano --- Makefile | 4 +- diff-tree.c | 226 ++++++---------------------------------------------- log-tree.c | 175 ++++++++++++++++++++++++++++++++++++++++ log-tree.h | 23 ++++++ 4 files changed, 224 insertions(+), 204 deletions(-) create mode 100644 log-tree.c create mode 100644 log-tree.h diff --git a/Makefile b/Makefile index 6b10eaa41..b2721469a 100644 --- a/Makefile +++ b/Makefile @@ -194,12 +194,12 @@ LIB_H = \ blob.h cache.h commit.h csum-file.h delta.h \ diff.h object.h pack.h pkt-line.h quote.h refs.h \ run-command.h strbuf.h tag.h tree.h git-compat-util.h revision.h \ - tree-walk.h + tree-walk.h log-tree.h DIFF_OBJS = \ diff.o diffcore-break.o diffcore-order.o diffcore-pathspec.o \ diffcore-pickaxe.o diffcore-rename.o tree-diff.o combine-diff.o \ - diffcore-delta.o + diffcore-delta.o log-tree.o LIB_OBJS = \ blob.o commit.o connect.o csum-file.o \ diff --git a/diff-tree.c b/diff-tree.c index d1265d796..2a088d11c 100644 --- a/diff-tree.c +++ b/diff-tree.c @@ -1,152 +1,16 @@ #include "cache.h" #include "diff.h" #include "commit.h" +#include "log-tree.h" -static int show_root_diff = 0; -static int no_commit_id = 0; -static int verbose_header = 0; -static int ignore_merges = 1; -static int combine_merges = 0; -static int dense_combined_merges = 0; -static int read_stdin = 0; -static int always_show_header = 0; - -static const char *header = NULL; -static const char *header_prefix = ""; -static enum cmit_fmt commit_format = CMIT_FMT_RAW; - -static struct diff_options diff_options; - -static int call_diff_flush(void) -{ - diffcore_std(&diff_options); - if (diff_queue_is_empty()) { - int saved_fmt = diff_options.output_format; - diff_options.output_format = DIFF_FORMAT_NO_OUTPUT; - diff_flush(&diff_options); - diff_options.output_format = saved_fmt; - return 0; - } - if (header) { - if (!no_commit_id) - printf("%s%c", header, diff_options.line_termination); - header = NULL; - } - diff_flush(&diff_options); - return 1; -} - -static int diff_tree_sha1_top(const unsigned char *old, - const unsigned char *new, const char *base) -{ - int ret; - - ret = diff_tree_sha1(old, new, base, &diff_options); - call_diff_flush(); - return ret; -} - -static int diff_root_tree(const unsigned char *new, const char *base) -{ - int retval; - void *tree; - struct tree_desc empty, real; - - tree = read_object_with_reference(new, tree_type, &real.size, NULL); - if (!tree) - die("unable to read root tree (%s)", sha1_to_hex(new)); - real.buf = tree; - - empty.buf = ""; - empty.size = 0; - retval = diff_tree(&empty, &real, base, &diff_options); - free(tree); - call_diff_flush(); - return retval; -} - -static const char *generate_header(const unsigned char *commit_sha1, - const unsigned char *parent_sha1, - const struct commit *commit) -{ - static char this_header[16384]; - int offset; - unsigned long len; - int abbrev = diff_options.abbrev; - const char *msg = commit->buffer; - - if (!verbose_header) - return sha1_to_hex(commit_sha1); - - len = strlen(msg); - - offset = sprintf(this_header, "%s%s ", - header_prefix, - diff_unique_abbrev(commit_sha1, abbrev)); - if (commit_sha1 != parent_sha1) - offset += sprintf(this_header + offset, "(from %s)\n", - parent_sha1 - ? diff_unique_abbrev(parent_sha1, abbrev) - : "root"); - else - offset += sprintf(this_header + offset, "(from parents)\n"); - offset += pretty_print_commit(commit_format, commit, len, - this_header + offset, - sizeof(this_header) - offset, abbrev); - if (always_show_header) { - puts(this_header); - return NULL; - } - return this_header; -} - -static int diff_tree_commit(struct commit *commit) -{ - struct commit_list *parents; - unsigned const char *sha1 = commit->object.sha1; - - /* Root commit? */ - if (show_root_diff && !commit->parents) { - header = generate_header(sha1, NULL, commit); - diff_root_tree(sha1, ""); - } - - /* More than one parent? */ - if (commit->parents && commit->parents->next) { - if (ignore_merges) - return 0; - else if (combine_merges) { - header = generate_header(sha1, sha1, commit); - header = diff_tree_combined_merge(sha1, header, - dense_combined_merges, - &diff_options); - if (!header && verbose_header) - header_prefix = "\ndiff-tree "; - return 0; - } - } - - for (parents = commit->parents; parents; parents = parents->next) { - struct commit *parent = parents->item; - header = generate_header(sha1, parent->object.sha1, commit); - diff_tree_sha1_top(parent->object.sha1, sha1, ""); - if (!header && verbose_header) { - header_prefix = "\ndiff-tree "; - /* - * Don't print multiple merge entries if we - * don't print the diffs. - */ - } - } - return 0; -} +static struct log_tree_opt log_tree_opt; static int diff_tree_commit_sha1(const unsigned char *sha1) { struct commit *commit = lookup_commit_reference(sha1); if (!commit) return -1; - return diff_tree_commit(commit); + return log_tree_commit(&log_tree_opt, commit); } static int diff_tree_stdin(char *line) @@ -184,7 +48,7 @@ static int diff_tree_stdin(char *line) pos += 41; } } - return diff_tree_commit(commit); + return log_tree_commit(&log_tree_opt, commit); } static const char diff_tree_usage[] = @@ -200,13 +64,15 @@ int main(int argc, const char **argv) char line[1000]; 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; - diff_setup(&diff_options); + init_log_tree_opt(opt); for (;;) { - int diff_opt_cnt; + int opt_cnt; const char *arg; argv++; @@ -223,84 +89,39 @@ int main(int argc, const char **argv) break; } - diff_opt_cnt = diff_opt_parse(&diff_options, argv, argc); - if (diff_opt_cnt < 0) + opt_cnt = log_tree_opt_parse(opt, argv, argc); + if (opt_cnt < 0) usage(diff_tree_usage); - else if (diff_opt_cnt) { - argv += diff_opt_cnt - 1; - argc -= diff_opt_cnt - 1; + else if (opt_cnt) { + argv += opt_cnt - 1; + argc -= opt_cnt - 1; continue; } - if (!strcmp(arg, "--")) { argv++; argc--; break; } - if (!strcmp(arg, "-r")) { - diff_options.recursive = 1; - continue; - } - if (!strcmp(arg, "-t")) { - diff_options.recursive = 1; - diff_options.tree_in_recursive = 1; - continue; - } - if (!strcmp(arg, "-m")) { - ignore_merges = 0; - continue; - } - if (!strcmp(arg, "-c")) { - combine_merges = 1; - continue; - } - if (!strcmp(arg, "--cc")) { - dense_combined_merges = combine_merges = 1; - continue; - } - if (!strcmp(arg, "-v")) { - verbose_header = 1; - header_prefix = "diff-tree "; - continue; - } - if (!strncmp(arg, "--pretty", 8)) { - verbose_header = 1; - header_prefix = "diff-tree "; - commit_format = get_commit_format(arg+8); - continue; - } if (!strcmp(arg, "--stdin")) { read_stdin = 1; continue; } - if (!strcmp(arg, "--root")) { - show_root_diff = 1; - continue; - } - if (!strcmp(arg, "--no-commit-id")) { - no_commit_id = 1; - continue; - } - if (!strcmp(arg, "--always")) { - always_show_header = 1; - continue; - } usage(diff_tree_usage); } - if (combine_merges) - ignore_merges = 0; + if (opt->combine_merges) + opt->ignore_merges = 0; /* We can only do dense combined merges with diff output */ - if (dense_combined_merges) - diff_options.output_format = DIFF_FORMAT_PATCH; + if (opt->dense_combined_merges) + opt->diffopt.output_format = DIFF_FORMAT_PATCH; - if (diff_options.output_format == DIFF_FORMAT_PATCH) - diff_options.recursive = 1; + if (opt->diffopt.output_format == DIFF_FORMAT_PATCH) + opt->diffopt.recursive = 1; diff_tree_setup_paths(get_pathspec(prefix, argv)); - diff_setup_done(&diff_options); + diff_setup_done(&opt->diffopt); switch (nr_sha1) { case 0: @@ -311,15 +132,16 @@ int main(int argc, const char **argv) diff_tree_commit_sha1(sha1[0]); break; case 2: - diff_tree_sha1_top(sha1[0], sha1[1], ""); + diff_tree_sha1(sha1[0], sha1[1], "", &opt->diffopt); + log_tree_diff_flush(opt); break; } if (!read_stdin) return 0; - if (diff_options.detect_rename) - diff_options.setup |= (DIFF_SETUP_USE_SIZE_CACHE | + if (opt->diffopt.detect_rename) + opt->diffopt.setup |= (DIFF_SETUP_USE_SIZE_CACHE | DIFF_SETUP_USE_CACHE); while (fgets(line, sizeof(line), stdin)) diff_tree_stdin(line); diff --git a/log-tree.c b/log-tree.c new file mode 100644 index 000000000..3d404824a --- /dev/null +++ b/log-tree.c @@ -0,0 +1,175 @@ +#include "cache.h" +#include "diff.h" +#include "commit.h" +#include "log-tree.h" + +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()) { + int saved_fmt = opt->diffopt.output_format; + opt->diffopt.output_format = DIFF_FORMAT_NO_OUTPUT; + diff_flush(&opt->diffopt); + opt->diffopt.output_format = saved_fmt; + return 0; + } + if (opt->header) { + if (!opt->no_commit_id) + printf("%s%c", opt->header, + opt->diffopt.line_termination); + opt->header = NULL; + } + diff_flush(&opt->diffopt); + return 1; +} + +static int diff_root_tree(struct log_tree_opt *opt, + const unsigned char *new, const char *base) +{ + int retval; + void *tree; + struct tree_desc empty, real; + + tree = read_object_with_reference(new, tree_type, &real.size, NULL); + if (!tree) + die("unable to read root tree (%s)", sha1_to_hex(new)); + real.buf = tree; + + empty.buf = ""; + empty.size = 0; + retval = diff_tree(&empty, &real, base, &opt->diffopt); + free(tree); + log_tree_diff_flush(opt); + return retval; +} + +static const char *generate_header(struct log_tree_opt *opt, + const unsigned char *commit_sha1, + const unsigned char *parent_sha1, + const struct commit *commit) +{ + static char this_header[16384]; + int offset; + unsigned long len; + int abbrev = opt->diffopt.abbrev; + const char *msg = commit->buffer; + + if (!opt->verbose_header) + return sha1_to_hex(commit_sha1); + + len = strlen(msg); + + offset = sprintf(this_header, "%s%s ", + opt->header_prefix, + diff_unique_abbrev(commit_sha1, abbrev)); + if (commit_sha1 != parent_sha1) + offset += sprintf(this_header + offset, "(from %s)\n", + parent_sha1 + ? diff_unique_abbrev(parent_sha1, abbrev) + : "root"); + else + offset += sprintf(this_header + offset, "(from parents)\n"); + offset += pretty_print_commit(opt->commit_format, commit, len, + this_header + offset, + sizeof(this_header) - offset, abbrev); + if (opt->always_show_header) { + puts(this_header); + return NULL; + } + return this_header; +} + +static int do_diff_combined(struct log_tree_opt *opt, struct commit *commit) +{ + unsigned const char *sha1 = commit->object.sha1; + + opt->header = generate_header(opt, sha1, sha1, commit); + opt->header = diff_tree_combined_merge(sha1, opt->header, + opt->dense_combined_merges, + &opt->diffopt); + if (!opt->header && opt->verbose_header) + opt->header_prefix = "\ndiff-tree "; + return 0; +} + +int log_tree_commit(struct log_tree_opt *opt, struct commit *commit) +{ + struct commit_list *parents; + unsigned const char *sha1 = commit->object.sha1; + + /* Root commit? */ + if (opt->show_root_diff && !commit->parents) { + opt->header = generate_header(opt, sha1, NULL, commit); + diff_root_tree(opt, sha1, ""); + } + + /* More than one parent? */ + if (commit->parents && commit->parents->next) { + if (opt->ignore_merges) + return 0; + else if (opt->combine_merges) + return do_diff_combined(opt, commit); + } + + for (parents = commit->parents; parents; parents = parents->next) { + struct commit *parent = parents->item; + unsigned const char *psha1 = parent->object.sha1; + opt->header = generate_header(opt, sha1, psha1, commit); + diff_tree_sha1(psha1, sha1, "", &opt->diffopt); + log_tree_diff_flush(opt); + + if (!opt->header && opt->verbose_header) + opt->header_prefix = "\ndiff-tree "; + } + return 0; +} diff --git a/log-tree.h b/log-tree.h new file mode 100644 index 000000000..da166c6f2 --- /dev/null +++ b/log-tree.h @@ -0,0 +1,23 @@ +#ifndef LOG_TREE_H +#define LOG_TREE_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 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 -- 2.30.2