tree-diff: no need to call "full" diff_tree_sha1 from show_path()

diff --git a/tree-diff.c b/tree-diff.c
index 0e43906b4318c0b5b4c31d874fe12eb570356790..80527c046472d41a03299b84ec9cc7fb1f0cd575 100644 (file)
--- a/tree-diff.c
+++ b/tree-diff.c
@@ -6,6 +6,10 @@
 #include "diffcore.h"
 #include "tree.h"
 
+
+static int ll_diff_tree_sha1(const unsigned char *old, const unsigned char *new,
+                            const char *base_str, struct diff_options *opt);
+
 /*
  * Compare two tree entries, taking into account only path/S_ISDIR(mode),
  * but not their sha1's.
@@ -118,8 +122,8 @@ static void show_path(struct strbuf *base, struct diff_options *opt,
 
        if (recurse) {
                strbuf_addch(base, '/');
-               diff_tree_sha1(t1 ? t1->entry.sha1 : NULL,
-                              t2 ? t2->entry.sha1 : NULL, base->buf, opt);
+               ll_diff_tree_sha1(t1 ? t1->entry.sha1 : NULL,
+                                 t2 ? t2->entry.sha1 : NULL, base->buf, opt);
        }
 
        strbuf_setlen(base, old_baselen);
@@ -141,12 +145,17 @@ static void skip_uninteresting(struct tree_desc *t, struct strbuf *base,
        }
 }
 
-static int diff_tree(struct tree_desc *t1, struct tree_desc *t2,
-                    const char *base_str, struct diff_options *opt)
+static int ll_diff_tree_sha1(const unsigned char *old, const unsigned char *new,
+                            const char *base_str, struct diff_options *opt)
 {
+       struct tree_desc t1, t2;
+       void *t1tree, *t2tree;
        struct strbuf base;
        int baselen = strlen(base_str);
 
+       t1tree = fill_tree_descriptor(&t1, old);
+       t2tree = fill_tree_descriptor(&t2, new);
+
        /* Enable recursion indefinitely */
        opt->pathspec.recursive = DIFF_OPT_TST(opt, RECURSIVE);
 
@@ -159,39 +168,41 @@ static int diff_tree(struct tree_desc *t1, struct tree_desc *t2,
                if (diff_can_quit_early(opt))
                        break;
                if (opt->pathspec.nr) {
-                       skip_uninteresting(t1, &base, opt);
-                       skip_uninteresting(t2, &base, opt);
+                       skip_uninteresting(&t1, &base, opt);
+                       skip_uninteresting(&t2, &base, opt);
                }
-               if (!t1->size && !t2->size)
+               if (!t1.size && !t2.size)
                        break;
 
-               cmp = tree_entry_pathcmp(t1, t2);
+               cmp = tree_entry_pathcmp(&t1, &t2);
 
                /* t1 = t2 */
                if (cmp == 0) {
                        if (DIFF_OPT_TST(opt, FIND_COPIES_HARDER) ||
-                           hashcmp(t1->entry.sha1, t2->entry.sha1) ||
-                           (t1->entry.mode != t2->entry.mode))
-                               show_path(&base, opt, t1, t2);
+                           hashcmp(t1.entry.sha1, t2.entry.sha1) ||
+                           (t1.entry.mode != t2.entry.mode))
+                               show_path(&base, opt, &t1, &t2);
 
-                       update_tree_entry(t1);
-                       update_tree_entry(t2);
+                       update_tree_entry(&t1);
+                       update_tree_entry(&t2);
                }
 
                /* t1 < t2 */
                else if (cmp < 0) {
-                       show_path(&base, opt, t1, /*t2=*/NULL);
-                       update_tree_entry(t1);
+                       show_path(&base, opt, &t1, /*t2=*/NULL);
+                       update_tree_entry(&t1);
                }
 
                /* t1 > t2 */
                else {
-                       show_path(&base, opt, /*t1=*/NULL, t2);
-                       update_tree_entry(t2);
+                       show_path(&base, opt, /*t1=*/NULL, &t2);
+                       update_tree_entry(&t2);
                }
        }
 
        strbuf_release(&base);
+       free(t2tree);
+       free(t1tree);
        return 0;
 }
 
@@ -206,7 +217,7 @@ static inline int diff_might_be_rename(void)
                !DIFF_FILE_VALID(diff_queued_diff.queue[0]->one);
 }
 
-static void try_to_follow_renames(struct tree_desc *t1, struct tree_desc *t2, const char *base, struct diff_options *opt)
+static void try_to_follow_renames(const unsigned char *old, const unsigned char *new, const char *base, struct diff_options *opt)
 {
        struct diff_options diff_opts;
        struct diff_queue_struct *q = &diff_queued_diff;
@@ -244,7 +255,7 @@ static void try_to_follow_renames(struct tree_desc *t1, struct tree_desc *t2, co
        diff_opts.break_opt = opt->break_opt;
        diff_opts.rename_score = opt->rename_score;
        diff_setup_done(&diff_opts);
-       diff_tree(t1, t2, base, &diff_opts);
+       ll_diff_tree_sha1(old, new, base, &diff_opts);
        diffcore_std(&diff_opts);
        free_pathspec(&diff_opts.pathspec);
 
@@ -305,23 +316,12 @@ static void try_to_follow_renames(struct tree_desc *t1, struct tree_desc *t2, co
 
 int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const char *base, struct diff_options *opt)
 {
-       void *tree1, *tree2;
-       struct tree_desc t1, t2;
-       unsigned long size1, size2;
        int retval;
 
-       tree1 = fill_tree_descriptor(&t1, old);
-       tree2 = fill_tree_descriptor(&t2, new);
-       size1 = t1.size;
-       size2 = t2.size;
-       retval = diff_tree(&t1, &t2, base, opt);
-       if (!*base && DIFF_OPT_TST(opt, FOLLOW_RENAMES) && diff_might_be_rename()) {
-               init_tree_desc(&t1, tree1, size1);
-               init_tree_desc(&t2, tree2, size2);
-               try_to_follow_renames(&t1, &t2, base, opt);
-       }
-       free(tree1);
-       free(tree2);
+       retval = ll_diff_tree_sha1(old, new, base, opt);
+       if (!*base && DIFF_OPT_TST(opt, FOLLOW_RENAMES) && diff_might_be_rename())
+               try_to_follow_renames(old, new, base, opt);
+
        return retval;
 }