Merge branch 'jc/combine' into next
authorJunio C Hamano <junkio@cox.net>
Wed, 12 Apr 2006 20:24:48 +0000 (13:24 -0700)
committerJunio C Hamano <junkio@cox.net>
Wed, 12 Apr 2006 20:24:48 +0000 (13:24 -0700)
* jc/combine:
stripspace: make sure not to leave an incomplete line.
git-commit: do not muck with commit message when no_edit is set.
When showing a commit message, do not lose an incomplete line.
Retire t5501-old-fetch-and-upload test.
combine-diff: type fix.

18 files changed:
Documentation/diff-options.txt
Documentation/git-apply.txt
Makefile
apply.c
blame.c
combine-diff.c
diff-tree.c
diff.c
diff.h
git.c
http-fetch.c
http-push.c
log-tree.c [new file with mode: 0644]
log-tree.h [new file with mode: 0644]
rev-list.c
revision.c
revision.h
tree-diff.c
index ec6811c71885a9aa0a28626c46e0645cd79864ac..338014c8162c1576796a57ab61498612948fe9dc 100644 (file)
@@ -4,6 +4,9 @@
 -u::
        Synonym for "-p".
 
+--patch-with-raw::
+       Generate patch but keep also the default raw diff output.
+
 -z::
        \0 line termination on output
 
index 1c64a1aa82648db90251816f1b75dbdc9e7186e3..e93ea1f26554f99e9dee532e0fa585309ae43110 100644 (file)
@@ -11,7 +11,7 @@ SYNOPSIS
 [verse]
 'git-apply' [--stat] [--numstat] [--summary] [--check] [--index] [--apply]
          [--no-add] [--index-info] [--allow-binary-replacement] [-z] [-pNUM]
-         [--whitespace=<nowarn|warn|error|error-all|strip>]
+         [-CNUM] [--whitespace=<nowarn|warn|error|error-all|strip>]
          [<patch>...]
 
 DESCRIPTION
@@ -73,6 +73,12 @@ OPTIONS
        Remove <n> leading slashes from traditional diff paths. The
        default is 1.
 
+-C<n>::
+       Ensure at least <n> lines of surrounding context match before
+       and after each change.  When fewer lines of surrounding
+       context exist they all most match.  By default no context is
+       ever ignored.
+
 --apply::
        If you use any of the options marked ``Turns off
        "apply"'' above, git-apply reads and outputs the
index 50c5ccb9c3eae281e3fc1c7c16810c56c70ef9b8..e6ef41d70240c242d1bfab244067d04518a4d552 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -196,12 +196,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-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/apply.c b/apply.c
index 33b4271288d3ee6ac786d7fc6009df1bf354055e..269210a578262b22fbf50bbdd9bf9fbccec3202b 100644 (file)
--- a/apply.c
+++ b/apply.c
@@ -32,8 +32,9 @@ static int apply = 1;
 static int no_add = 0;
 static int show_index_info = 0;
 static int line_termination = '\n';
+static unsigned long p_context = -1;
 static const char apply_usage[] =
-"git-apply [--stat] [--numstat] [--summary] [--check] [--index] [--apply] [--no-add] [--index-info] [--allow-binary-replacement] [-z] [-pNUM] [--whitespace=<nowarn|warn|error|error-all|strip>] <patch>...";
+"git-apply [--stat] [--numstat] [--summary] [--check] [--index] [--apply] [--no-add] [--index-info] [--allow-binary-replacement] [-z] [-pNUM] [-CNUM] [--whitespace=<nowarn|warn|error|error-all|strip>] <patch>...";
 
 static enum whitespace_eol {
        nowarn_whitespace,
@@ -100,6 +101,7 @@ static int max_change, max_len;
 static int linenr = 1;
 
 struct fragment {
+       unsigned long leading, trailing;
        unsigned long oldpos, oldlines;
        unsigned long newpos, newlines;
        const char *patch;
@@ -817,12 +819,15 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s
        int added, deleted;
        int len = linelen(line, size), offset;
        unsigned long oldlines, newlines;
+       unsigned long leading, trailing;
 
        offset = parse_fragment_header(line, len, fragment);
        if (offset < 0)
                return -1;
        oldlines = fragment->oldlines;
        newlines = fragment->newlines;
+       leading = 0;
+       trailing = 0;
 
        if (patch->is_new < 0) {
                patch->is_new =  !oldlines;
@@ -860,10 +865,14 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s
                case ' ':
                        oldlines--;
                        newlines--;
+                       if (!deleted && !added)
+                               leading++;
+                       trailing++;
                        break;
                case '-':
                        deleted++;
                        oldlines--;
+                       trailing = 0;
                        break;
                case '+':
                        /*
@@ -887,6 +896,7 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s
                        }
                        added++;
                        newlines--;
+                       trailing = 0;
                        break;
 
                 /* We allow "\ No newline at end of file". Depending
@@ -904,6 +914,9 @@ static int parse_fragment(char *line, unsigned long size, struct patch *patch, s
        }
        if (oldlines || newlines)
                return -1;
+       fragment->leading = leading;
+       fragment->trailing = trailing;
+
        /* If a fragment ends with an incomplete line, we failed to include
         * it in the above loop because we hit oldlines == newlines == 0
         * before seeing it.
@@ -1087,7 +1100,7 @@ static int read_old_data(struct stat *st, const char *path, void *buf, unsigned
        }
 }
 
-static int find_offset(const char *buf, unsigned long size, const char *fragment, unsigned long fragsize, int line)
+static int find_offset(const char *buf, unsigned long size, const char *fragment, unsigned long fragsize, int line, int *lines)
 {
        int i;
        unsigned long start, backwards, forwards;
@@ -1148,6 +1161,7 @@ static int find_offset(const char *buf, unsigned long size, const char *fragment
                n = (i >> 1)+1;
                if (i & 1)
                        n = -n;
+               *lines = n;
                return try;
        }
 
@@ -1157,6 +1171,33 @@ static int find_offset(const char *buf, unsigned long size, const char *fragment
        return -1;
 }
 
+static void remove_first_line(const char **rbuf, int *rsize)
+{
+       const char *buf = *rbuf;
+       int size = *rsize;
+       unsigned long offset;
+       offset = 0;
+       while (offset <= size) {
+               if (buf[offset++] == '\n')
+                       break;
+       }
+       *rsize = size - offset;
+       *rbuf = buf + offset;
+}
+
+static void remove_last_line(const char **rbuf, int *rsize)
+{
+       const char *buf = *rbuf;
+       int size = *rsize;
+       unsigned long offset;
+       offset = size - 1;
+       while (offset > 0) {
+               if (buf[--offset] == '\n')
+                       break;
+       }
+       *rsize = offset + 1;
+}
+
 struct buffer_desc {
        char *buffer;
        unsigned long size;
@@ -1192,7 +1233,10 @@ static int apply_one_fragment(struct buffer_desc *desc, struct fragment *frag)
        int offset, size = frag->size;
        char *old = xmalloc(size);
        char *new = xmalloc(size);
+       const char *oldlines, *newlines;
        int oldsize = 0, newsize = 0;
+       unsigned long leading, trailing;
+       int pos, lines;
 
        while (size > 0) {
                int len = linelen(patch, size);
@@ -1241,23 +1285,59 @@ static int apply_one_fragment(struct buffer_desc *desc, struct fragment *frag)
                newsize--;
        }
 #endif
-                       
-       offset = find_offset(buf, desc->size, old, oldsize, frag->newpos);
-       if (offset >= 0) {
-               int diff = newsize - oldsize;
-               unsigned long size = desc->size + diff;
-               unsigned long alloc = desc->alloc;
-
-               if (size > alloc) {
-                       alloc = size + 8192;
-                       desc->alloc = alloc;
-                       buf = xrealloc(buf, alloc);
-                       desc->buffer = buf;
+
+       oldlines = old;
+       newlines = new;
+       leading = frag->leading;
+       trailing = frag->trailing;
+       lines = 0;
+       pos = frag->newpos;
+       for (;;) {
+               offset = find_offset(buf, desc->size, oldlines, oldsize, pos, &lines);
+               if (offset >= 0) {
+                       int diff = newsize - oldsize;
+                       unsigned long size = desc->size + diff;
+                       unsigned long alloc = desc->alloc;
+
+                       /* Warn if it was necessary to reduce the number
+                        * of context lines.
+                        */
+                       if ((leading != frag->leading) || (trailing != frag->trailing))
+                               fprintf(stderr, "Context reduced to (%ld/%ld) to apply fragment at %d\n",
+                                       leading, trailing, pos + lines);
+
+                       if (size > alloc) {
+                               alloc = size + 8192;
+                               desc->alloc = alloc;
+                               buf = xrealloc(buf, alloc);
+                               desc->buffer = buf;
+                       }
+                       desc->size = size;
+                       memmove(buf + offset + newsize, buf + offset + oldsize, size - offset - newsize);
+                       memcpy(buf + offset, newlines, newsize);
+                       offset = 0;
+
+                       break;
+               }
+
+               /* Am I at my context limits? */
+               if ((leading <= p_context) && (trailing <= p_context))
+                       break;
+               /* Reduce the number of context lines
+                * Reduce both leading and trailing if they are equal
+                * otherwise just reduce the larger context.
+                */
+               if (leading >= trailing) {
+                       remove_first_line(&oldlines, &oldsize);
+                       remove_first_line(&newlines, &newsize);
+                       pos--;
+                       leading--;
+               }
+               if (trailing > leading) {
+                       remove_last_line(&oldlines, &oldsize);
+                       remove_last_line(&newlines, &newsize);
+                       trailing--;
                }
-               desc->size = size;
-               memmove(buf + offset + newsize, buf + offset + oldsize, size - offset - newsize);
-               memcpy(buf + offset, new, newsize);
-               offset = 0;
        }
 
        free(old);
@@ -1882,6 +1962,7 @@ int main(int argc, char **argv)
 
        for (i = 1; i < argc; i++) {
                const char *arg = argv[i];
+               char *end;
                int fd;
 
                if (!strcmp(arg, "-")) {
@@ -1945,6 +2026,12 @@ int main(int argc, char **argv)
                        line_termination = 0;
                        continue;
                }
+               if (!strncmp(arg, "-C", 2)) {
+                       p_context = strtoul(arg + 2, &end, 0);
+                       if (*end != '\0')
+                               die("unrecognized context count '%s'", arg + 2);
+                       continue;
+               }
                if (!strncmp(arg, "--whitespace=", 13)) {
                        whitespace_option = arg + 13;
                        parse_whitespace_option(arg + 13);
diff --git a/blame.c b/blame.c
index 6730b10b115250e088887879d075559a36ddc7b1..07d2d272514bdf68adf756dcb111b47226fbd1d8 100644 (file)
--- a/blame.c
+++ b/blame.c
@@ -508,25 +508,33 @@ static void process_commits(struct rev_info *rev, const char *path,
 static int compare_tree_path(struct rev_info* revs,
                             struct commit* c1, struct commit* c2)
 {
+       int ret;
        const char* paths[2];
        struct util_info* util = c2->object.util;
        paths[0] = util->pathname;
        paths[1] = NULL;
 
-       diff_tree_setup_paths(get_pathspec(revs->prefix, paths));
-       return rev_compare_tree(c1->tree, c2->tree);
+       diff_tree_setup_paths(get_pathspec(revs->prefix, paths),
+                             &revs->diffopt);
+       ret = rev_compare_tree(revs, c1->tree, c2->tree);
+       diff_tree_release_paths(&revs->diffopt);
+       return ret;
 }
 
 
 static int same_tree_as_empty_path(struct rev_info *revs, struct tree* t1,
                                   const char* path)
 {
+       int ret;
        const char* paths[2];
        paths[0] = path;
        paths[1] = NULL;
 
-       diff_tree_setup_paths(get_pathspec(revs->prefix, paths));
-       return rev_same_tree_as_empty(t1);
+       diff_tree_setup_paths(get_pathspec(revs->prefix, paths),
+                             &revs->diffopt);
+       ret = rev_same_tree_as_empty(revs, t1);
+       diff_tree_release_paths(&revs->diffopt);
+       return ret;
 }
 
 static const char* find_rename(struct commit* commit, struct commit* parent)
@@ -546,7 +554,7 @@ static const char* find_rename(struct commit* commit, struct commit* parent)
        diff_opts.recursive = 1;
        diff_opts.detect_rename = DIFF_DETECT_RENAME;
        paths[0] = NULL;
-       diff_tree_setup_paths(paths);
+       diff_tree_setup_paths(paths, &diff_opts);
        if (diff_setup_done(&diff_opts) < 0)
                die("diff_setup_done failed");
 
@@ -826,7 +834,7 @@ int main(int argc, const char **argv)
 
        args[0] = filename;
        args[1] = NULL;
-       diff_tree_setup_paths(args);
+       diff_tree_setup_paths(args, &rev.diffopt);
        prepare_revision_walk(&rev);
        process_commits(&rev, filename, &initial);
 
index e519583650c16ab4077c834f409658c63b6d5a06..9bd27f82ec1d7c313987325a4948a5eed8c9b799 100644 (file)
@@ -843,6 +843,7 @@ const char *diff_tree_combined_merge(const unsigned char *sha1,
 
        diffopts = *opt;
        diffopts.output_format = DIFF_FORMAT_NO_OUTPUT;
+       diffopts.with_raw = 0;
        diffopts.recursive = 1;
 
        /* count parents */
@@ -869,6 +870,17 @@ const char *diff_tree_combined_merge(const unsigned char *sha1,
                        num_paths++;
        }
        if (num_paths) {
+               if (opt->with_raw) {
+                       int saved_format = opt->output_format;
+                       opt->output_format = DIFF_FORMAT_RAW;
+                       for (p = paths; p; p = p->next) {
+                               if (show_combined_diff(p, num_parent, dense,
+                                                      header, opt))
+                                       header = NULL;
+                       }
+                       opt->output_format = saved_format;
+                       putchar(opt->line_termination);
+               }
                for (p = paths; p; p = p->next) {
                        if (show_combined_diff(p, num_parent, dense,
                                               header, opt))
index d1265d796388dd1c1a56c00f793893ee9dc6ed10..2b79dd0a68c30343d74e3e82c056fef6a355e82e 100644 (file)
 #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_tree_setup_paths(get_pathspec(prefix, argv), opt);
+       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/diff.c b/diff.c
index 2fa285a8efc69fac1ba922b0b7ada9230de93c79..a14e6644ca9a39d0a0e1702ccefadf7a5bb64081 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -862,6 +862,10 @@ int diff_opt_parse(struct diff_options *options, const char **av, int ac)
        const char *arg = av[0];
        if (!strcmp(arg, "-p") || !strcmp(arg, "-u"))
                options->output_format = DIFF_FORMAT_PATCH;
+       else if (!strcmp(arg, "--patch-with-raw")) {
+               options->output_format = DIFF_FORMAT_PATCH;
+               options->with_raw = 1;
+       }
        else if (!strcmp(arg, "-z"))
                options->line_termination = 0;
        else if (!strncmp(arg, "-l", 2))
@@ -1048,13 +1052,13 @@ const char *diff_unique_abbrev(const unsigned char *sha1, int len)
 static void diff_flush_raw(struct diff_filepair *p,
                           int line_termination,
                           int inter_name_termination,
-                          struct diff_options *options)
+                          struct diff_options *options,
+                          int output_format)
 {
        int two_paths;
        char status[10];
        int abbrev = options->abbrev;
        const char *path_one, *path_two;
-       int output_format = options->output_format;
 
        path_one = p->one->path;
        path_two = p->two->path;
@@ -1270,46 +1274,59 @@ static void diff_resolve_rename_copy(void)
        diff_debug_queue("resolve-rename-copy done", q);
 }
 
-void diff_flush(struct diff_options *options)
+static void flush_one_pair(struct diff_filepair *p,
+                          int diff_output_format,
+                          struct diff_options *options)
 {
-       struct diff_queue_struct *q = &diff_queued_diff;
-       int i;
        int inter_name_termination = '\t';
-       int diff_output_format = options->output_format;
        int line_termination = options->line_termination;
-
        if (!line_termination)
                inter_name_termination = 0;
 
-       for (i = 0; i < q->nr; i++) {
-               struct diff_filepair *p = q->queue[i];
-
-               switch (p->status) {
-               case DIFF_STATUS_UNKNOWN:
+       switch (p->status) {
+       case DIFF_STATUS_UNKNOWN:
+               break;
+       case 0:
+               die("internal error in diff-resolve-rename-copy");
+               break;
+       default:
+               switch (diff_output_format) {
+               case DIFF_FORMAT_PATCH:
+                       diff_flush_patch(p, options);
                        break;
-               case 0:
-                       die("internal error in diff-resolve-rename-copy");
+               case DIFF_FORMAT_RAW:
+               case DIFF_FORMAT_NAME_STATUS:
+                       diff_flush_raw(p, line_termination,
+                                      inter_name_termination,
+                                      options, diff_output_format);
+                       break;
+               case DIFF_FORMAT_NAME:
+                       diff_flush_name(p,
+                                       inter_name_termination,
+                                       line_termination);
+                       break;
+               case DIFF_FORMAT_NO_OUTPUT:
                        break;
-               default:
-                       switch (diff_output_format) {
-                       case DIFF_FORMAT_PATCH:
-                               diff_flush_patch(p, options);
-                               break;
-                       case DIFF_FORMAT_RAW:
-                       case DIFF_FORMAT_NAME_STATUS:
-                               diff_flush_raw(p, line_termination,
-                                              inter_name_termination,
-                                              options);
-                               break;
-                       case DIFF_FORMAT_NAME:
-                               diff_flush_name(p,
-                                               inter_name_termination,
-                                               line_termination);
-                               break;
-                       case DIFF_FORMAT_NO_OUTPUT:
-                               break;
-                       }
                }
+       }
+}
+
+void diff_flush(struct diff_options *options)
+{
+       struct diff_queue_struct *q = &diff_queued_diff;
+       int i;
+       int diff_output_format = options->output_format;
+
+       if (options->with_raw) {
+               for (i = 0; i < q->nr; i++) {
+                       struct diff_filepair *p = q->queue[i];
+                       flush_one_pair(p, DIFF_FORMAT_RAW, options);
+               }
+               putchar(options->line_termination);
+       }
+       for (i = 0; i < q->nr; i++) {
+               struct diff_filepair *p = q->queue[i];
+               flush_one_pair(p, diff_output_format, options);
                diff_free_filepair(p);
        }
        free(q->queue);
diff --git a/diff.h b/diff.h
index a02ef28201814e26f685509607dd6fef31298181..236095fc9a1a6ffc056be8616c0f83e4e8c7ec2f 100644 (file)
--- a/diff.h
+++ b/diff.h
@@ -24,6 +24,7 @@ struct diff_options {
        const char *orderfile;
        const char *pickaxe;
        unsigned recursive:1,
+                with_raw:1,
                 tree_in_recursive:1,
                 full_index:1;
        int break_opt;
@@ -38,11 +39,15 @@ struct diff_options {
        int setup;
        int abbrev;
 
+       int nr_paths;
+       const char **paths;
+       int *pathlens;
        change_fn_t change;
        add_remove_fn_t add_remove;
 };
 
-extern void diff_tree_setup_paths(const char **paths);
+extern void diff_tree_setup_paths(const char **paths, struct diff_options *);
+extern void diff_tree_release_paths(struct diff_options *);
 extern int diff_tree(struct tree_desc *t1, struct tree_desc *t2,
                     const char *base, struct diff_options *opt);
 extern int diff_tree_sha1(const unsigned char *old, const unsigned char *new,
@@ -112,6 +117,8 @@ extern void diffcore_std_no_resolve(struct diff_options *);
 "  -z            output diff-raw with lines terminated with NUL.\n" \
 "  -p            output patch format.\n" \
 "  -u            synonym for -p.\n" \
+"  --patch-with-raw\n" \
+"                output both a patch and the diff-raw format.\n" \
 "  --name-only   show only names of changed files.\n" \
 "  --name-status show names and status of changed files.\n" \
 "  --full-index  show full object name on index lines.\n" \
diff --git a/git.c b/git.c
index fa58232ddf146ee9edcf51403e551f8d2fa015a5..5cb0d32070bfdc067ac02c4a5186c3f2db3d5619 100644 (file)
--- a/git.c
+++ b/git.c
@@ -15,7 +15,9 @@
 
 #include "cache.h"
 #include "commit.h"
+#include "diff.h"
 #include "revision.h"
+#include "log-tree.h"
 
 #ifndef PATH_MAX
 # define PATH_MAX 4096
@@ -285,7 +287,12 @@ static int cmd_log(int argc, const char **argv, char **envp)
        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;
 
+       init_log_tree_opt(&opt);
        argc = setup_revisions(argc, argv, &rev, "HEAD");
        while (1 < argc) {
                const char *arg = argv[1];
@@ -310,14 +317,45 @@ static int cmd_log(int argc, const char **argv, char **envp)
                        else if (40 < abbrev)
                                abbrev = 40;
                }
-               else
+               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);
+               }
+
                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 (commit_format != CMIT_FMT_ONELINE && shown)
+                       putchar('\n');
                fputs(commit_prefix, stdout);
                if (abbrev_commit && abbrev)
                        fputs(find_unique_abbrev(commit->object.sha1, abbrev),
@@ -350,6 +388,9 @@ static int cmd_log(int argc, const char **argv, char **envp)
                pretty_print_commit(commit_format, commit, ~0, buf,
                                    LOGSIZE, abbrev);
                printf("%s\n", buf);
+               if (do_diff)
+                       log_tree_commit(&opt, commit);
+               shown = 1;
        }
        free(buf);
        return 0;
index 71a7dafd696d0da3a9662fb19cd83f87df1ec9b4..861644b27ee0c01a780b68daa43c259dd978a538 100644 (file)
@@ -597,7 +597,7 @@ static void process_alternates_response(void *callback_data)
                                newalt->packs = NULL;
                                path = strstr(target, "//");
                                if (path) {
-                                       path = index(path+2, '/');
+                                       path = strchr(path+2, '/');
                                        if (path)
                                                newalt->path_len = strlen(path);
                                }
@@ -678,7 +678,7 @@ static void
 xml_start_tag(void *userData, const char *name, const char **atts)
 {
        struct xml_ctx *ctx = (struct xml_ctx *)userData;
-       const char *c = index(name, ':');
+       const char *c = strchr(name, ':');
        int new_len;
 
        if (c == NULL)
@@ -707,7 +707,7 @@ static void
 xml_end_tag(void *userData, const char *name)
 {
        struct xml_ctx *ctx = (struct xml_ctx *)userData;
-       const char *c = index(name, ':');
+       const char *c = strchr(name, ':');
        char *ep;
 
        ctx->userFunc(ctx, 1);
@@ -1261,7 +1261,7 @@ int main(int argc, char **argv)
        alt->next = NULL;
        path = strstr(url, "//");
        if (path) {
-               path = index(path+2, '/');
+               path = strchr(path+2, '/');
                if (path)
                        alt->path_len = strlen(path);
        }
index 57cefdea530171c71c72229a85aa0212dedb2c5a..19a0f772e7bf729755c66ab38f5dfb64ae784f00 100644 (file)
@@ -6,6 +6,7 @@
 #include "blob.h"
 #include "http.h"
 #include "refs.h"
+#include "diff.h"
 #include "revision.h"
 #include "exec_cmd.h"
 
@@ -1211,7 +1212,7 @@ static void
 xml_start_tag(void *userData, const char *name, const char **atts)
 {
        struct xml_ctx *ctx = (struct xml_ctx *)userData;
-       const char *c = index(name, ':');
+       const char *c = strchr(name, ':');
        int new_len;
 
        if (c == NULL)
@@ -1240,7 +1241,7 @@ static void
 xml_end_tag(void *userData, const char *name)
 {
        struct xml_ctx *ctx = (struct xml_ctx *)userData;
-       const char *c = index(name, ':');
+       const char *c = strchr(name, ':');
        char *ep;
 
        ctx->userFunc(ctx, 1);
@@ -2350,7 +2351,7 @@ int main(int argc, char **argv)
                        char *path = strstr(arg, "//");
                        remote->url = arg;
                        if (path) {
-                               path = index(path+2, '/');
+                               path = strchr(path+2, '/');
                                if (path)
                                        remote->path_len = strlen(path);
                        }
diff --git a/log-tree.c b/log-tree.c
new file mode 100644 (file)
index 0000000..3d40482
--- /dev/null
@@ -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 (file)
index 0000000..da166c6
--- /dev/null
@@ -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
index 359195b5471d8e4b88fd9a326986e55d48b1dfa6..963707a495092405c3eb5b155c195b2968afdac7 100644 (file)
@@ -5,6 +5,7 @@
 #include "tree.h"
 #include "blob.h"
 #include "tree-walk.h"
+#include "diff.h"
 #include "revision.h"
 
 /* bits #0-6 in revision.h */
index fe265623817c7c6b5b4c1af399f4522a75fdaf30..0505f3f455151ac2fafc7fe2df2e6fd147d20f08 100644 (file)
@@ -233,25 +233,20 @@ static void file_change(struct diff_options *options,
        tree_difference = REV_TREE_DIFFERENT;
 }
 
-static struct diff_options diff_opt = {
-       .recursive = 1,
-       .add_remove = file_add_remove,
-       .change = file_change,
-};
-
-int rev_compare_tree(struct tree *t1, struct tree *t2)
+int rev_compare_tree(struct rev_info *revs, struct tree *t1, struct tree *t2)
 {
        if (!t1)
                return REV_TREE_NEW;
        if (!t2)
                return REV_TREE_DIFFERENT;
        tree_difference = REV_TREE_SAME;
-       if (diff_tree_sha1(t1->object.sha1, t2->object.sha1, "", &diff_opt) < 0)
+       if (diff_tree_sha1(t1->object.sha1, t2->object.sha1, "",
+                          &revs->diffopt) < 0)
                return REV_TREE_DIFFERENT;
        return tree_difference;
 }
 
-int rev_same_tree_as_empty(struct tree *t1)
+int rev_same_tree_as_empty(struct rev_info *revs, struct tree *t1)
 {
        int retval;
        void *tree;
@@ -269,7 +264,7 @@ int rev_same_tree_as_empty(struct tree *t1)
        empty.size = 0;
 
        tree_difference = 0;
-       retval = diff_tree(&empty, &real, "", &diff_opt);
+       retval = diff_tree(&empty, &real, "", &revs->diffopt);
        free(tree);
 
        return retval >= 0 && !tree_difference;
@@ -284,7 +279,7 @@ static void try_to_simplify_commit(struct rev_info *revs, struct commit *commit)
                return;
 
        if (!commit->parents) {
-               if (!rev_same_tree_as_empty(commit->tree))
+               if (!rev_same_tree_as_empty(revs, commit->tree))
                        commit->object.flags |= TREECHANGE;
                return;
        }
@@ -294,7 +289,7 @@ static void try_to_simplify_commit(struct rev_info *revs, struct commit *commit)
                struct commit *p = parent->item;
 
                parse_commit(p);
-               switch (rev_compare_tree(p->tree, commit->tree)) {
+               switch (rev_compare_tree(revs, p->tree, commit->tree)) {
                case REV_TREE_SAME:
                        if (p->object.flags & UNINTERESTING) {
                                /* Even if a merge with an uninteresting
@@ -312,7 +307,7 @@ static void try_to_simplify_commit(struct rev_info *revs, struct commit *commit)
 
                case REV_TREE_NEW:
                        if (revs->remove_empty_trees &&
-                           rev_same_tree_as_empty(p->tree)) {
+                           rev_same_tree_as_empty(revs, p->tree)) {
                                /* We are adding all the specified
                                 * paths from this parent, so the
                                 * history beyond this parent is not
@@ -484,6 +479,9 @@ static void handle_all(struct rev_info *revs, unsigned flags)
 void init_revisions(struct rev_info *revs)
 {
        memset(revs, 0, sizeof(*revs));
+       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();
@@ -707,7 +705,7 @@ int setup_revisions(int argc, const char **argv, struct rev_info *revs, const ch
                revs->limited = 1;
 
        if (revs->prune_data) {
-               diff_tree_setup_paths(revs->prune_data);
+               diff_tree_setup_paths(revs->prune_data, &revs->diffopt);
                revs->prune_fn = try_to_simplify_commit;
        }
 
index 83d28d520557ae37eea59dd7446e46edb6ef7cf6..8970b57e3c7e2ca8d213258f1befb84ac06e3a13 100644 (file)
@@ -43,6 +43,9 @@ struct rev_info {
        unsigned long max_age;
        unsigned long min_age;
 
+       /* paths limiting */
+       struct diff_options diffopt;
+
        topo_sort_set_fn_t topo_setter;
        topo_sort_get_fn_t topo_getter;
 };
@@ -52,8 +55,8 @@ struct rev_info {
 #define REV_TREE_DIFFERENT     2
 
 /* revision.c */
-extern int rev_same_tree_as_empty(struct tree *t1);
-extern int rev_compare_tree(struct tree *t1, struct tree *t2);
+extern int rev_same_tree_as_empty(struct rev_info *, struct tree *t1);
+extern int rev_compare_tree(struct rev_info *, struct tree *t1, struct tree *t2);
 
 extern void init_revisions(struct rev_info *revs);
 extern int setup_revisions(int argc, const char **argv, struct rev_info *revs, const char *def);
index 701fbba65c2d718a2cdff170a6be6d9993ad27d7..1cdf8aa90850441d60553281a1928047563fe8a6 100644 (file)
@@ -5,11 +5,6 @@
 #include "diff.h"
 #include "tree.h"
 
-// What paths are we interested in?
-static int nr_paths = 0;
-static const char **paths = NULL;
-static int *pathlens = NULL;
-
 static char *malloc_base(const char *base, const char *path, int pathlen)
 {
        int baselen = strlen(base);
@@ -72,14 +67,14 @@ static int compare_tree_entry(struct tree_desc *t1, struct tree_desc *t2, const
        return 0;
 }
 
-static int interesting(struct tree_desc *desc, const char *base)
+static int interesting(struct tree_desc *desc, const char *base, struct diff_options *opt)
 {
        const char *path;
        unsigned mode;
        int i;
        int baselen, pathlen;
 
-       if (!nr_paths)
+       if (!opt->nr_paths)
                return 1;
 
        (void)tree_entry_extract(desc, &path, &mode);
@@ -87,9 +82,9 @@ static int interesting(struct tree_desc *desc, const char *base)
        pathlen = strlen(path);
        baselen = strlen(base);
 
-       for (i=0; i < nr_paths; i++) {
-               const char *match = paths[i];
-               int matchlen = pathlens[i];
+       for (i=0; i < opt->nr_paths; i++) {
+               const char *match = opt->paths[i];
+               int matchlen = opt->pathlens[i];
 
                if (baselen >= matchlen) {
                        /* If it doesn't match, move along... */
@@ -129,7 +124,7 @@ static int interesting(struct tree_desc *desc, const char *base)
 static void show_tree(struct diff_options *opt, const char *prefix, struct tree_desc *desc, const char *base)
 {
        while (desc->size) {
-               if (interesting(desc, base))
+               if (interesting(desc, base, opt))
                        show_entry(opt, prefix, desc, base);
                update_tree_entry(desc);
        }
@@ -167,11 +162,11 @@ static int show_entry(struct diff_options *opt, const char *prefix, struct tree_
 int diff_tree(struct tree_desc *t1, struct tree_desc *t2, const char *base, struct diff_options *opt)
 {
        while (t1->size | t2->size) {
-               if (nr_paths && t1->size && !interesting(t1, base)) {
+               if (opt->nr_paths && t1->size && !interesting(t1, base, opt)) {
                        update_tree_entry(t1);
                        continue;
                }
-               if (nr_paths && t2->size && !interesting(t2, base)) {
+               if (opt->nr_paths && t2->size && !interesting(t2, base, opt)) {
                        update_tree_entry(t2);
                        continue;
                }
@@ -229,19 +224,28 @@ static int count_paths(const char **paths)
        return i;
 }
 
-void diff_tree_setup_paths(const char **p)
+void diff_tree_release_paths(struct diff_options *opt)
 {
+       free(opt->pathlens);
+}
+
+void diff_tree_setup_paths(const char **p, struct diff_options *opt)
+{
+       opt->nr_paths = 0;
+       opt->pathlens = NULL;
+       opt->paths = NULL;
+
        if (p) {
                int i;
 
-               paths = p;
-               nr_paths = count_paths(paths);
-               if (nr_paths == 0) {
-                       pathlens = NULL;
+               opt->paths = p;
+               opt->nr_paths = count_paths(p);
+               if (opt->nr_paths == 0) {
+                       opt->pathlens = NULL;
                        return;
                }
-               pathlens = xmalloc(nr_paths * sizeof(int));
-               for (i=0; i<nr_paths; i++)
-                       pathlens[i] = strlen(paths[i]);
+               opt->pathlens = xmalloc(opt->nr_paths * sizeof(int));
+               for (i=0; i < opt->nr_paths; i++)
+                       opt->pathlens[i] = strlen(p[i]);
        }
 }