Improve tree_entry_interesting() handling code

t_e_i() can return -1 or 2 to early shortcut a search. Current code
may use up to two variables to handle it. One for saving return value
from t_e_i temporarily, one for saving return code 2.

The second variable is not needed. If we make sure the first variable
does not change until the next t_e_i() call, then we can do something
like this:

int ret = 0;

while (...) {
if (ret != 2) {
ret = t_e_i();
if (ret < 0) /* no longer interesting */
break;
if (ret == 0) /* skip this round */
continue;
}
/* ret > 0, interesting */
}

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/grep.c b/builtin/grep.c
index c3af8760cc778b4eb835d4fb543f45aa333b214c..73b962f8329c6045fc98f49913045a8f6f5af52d 100644 (file)
--- a/builtin/grep.c
+++ b/builtin/grep.c
@@ -521,18 +521,18 @@ static int grep_cache(struct grep_opt *opt, const struct pathspec *pathspec, int
 static int grep_tree(struct grep_opt *opt, const struct pathspec *pathspec,
                     struct tree_desc *tree, struct strbuf *base, int tn_len)
 {
 static int grep_tree(struct grep_opt *opt, const struct pathspec *pathspec,
                     struct tree_desc *tree, struct strbuf *base, int tn_len)
 {

-       int hit = 0, matched = 0;
+       int hit = 0, match = 0;

        struct name_entry entry;
        int old_baselen = base->len;
 
        while (tree_entry(tree, &entry)) {
                int te_len = tree_entry_len(entry.path, entry.sha1);
 
        struct name_entry entry;
        int old_baselen = base->len;
 
        while (tree_entry(tree, &entry)) {
                int te_len = tree_entry_len(entry.path, entry.sha1);
 

-               if (matched != 2) {
-                       matched = tree_entry_interesting(&entry, base, tn_len, pathspec);
-                       if (matched == -1)
-                               break; /* no more matches */
-                       if (!matched)
+               if (match != 2) {
+                       match = tree_entry_interesting(&entry, base, tn_len, pathspec);
+                       if (match < 0)
+                               break;
+                       if (match == 0)

                                continue;
                }
 
                                continue;
                }
 

diff --git a/list-objects.c b/list-objects.c
index 61f6cc98d917c3e4395ec397ac74df6a40eeb07f..cf9dbe23e468948992db8d163f5b9395246ea5b8 100644 (file)
--- a/list-objects.c
+++ b/list-objects.c
@@ -68,7 +68,7 @@ static void process_tree(struct rev_info *revs,
        struct tree_desc desc;
        struct name_entry entry;
        struct name_path me;
        struct tree_desc desc;
        struct name_entry entry;
        struct name_path me;

-       int all_interesting = (revs->diffopt.pathspec.nr == 0);
+       int match = revs->diffopt.pathspec.nr == 0 ? 2 : 0;

        int baselen = base->len;
 
        if (!revs->tree_objects)
        int baselen = base->len;
 
        if (!revs->tree_objects)


@@ -85,7 +85,7 @@ static void process_tree(struct rev_info *revs,
        me.elem = name;
        me.elem_len = strlen(name);
 
        me.elem = name;
        me.elem_len = strlen(name);
 

-       if (!all_interesting) {
+       if (!match) {

                strbuf_addstr(base, name);
                if (base->len)
                        strbuf_addch(base, '/');
                strbuf_addstr(base, name);
                if (base->len)
                        strbuf_addch(base, '/');


@@ -94,17 +94,13 @@ static void process_tree(struct rev_info *revs,
        init_tree_desc(&desc, tree->buffer, tree->size);
 
        while (tree_entry(&desc, &entry)) {
        init_tree_desc(&desc, tree->buffer, tree->size);
 
        while (tree_entry(&desc, &entry)) {

-               if (!all_interesting) {
-                       int showit = tree_entry_interesting(&entry,
-                                                           base, 0,
-                                                           &revs->diffopt.pathspec);
-
-                       if (showit < 0)
+               if (match != 2) {
+                       match = tree_entry_interesting(&entry, base, 0,
+                                                      &revs->diffopt.pathspec);
+                       if (match < 0)

                                break;
                                break;

-                       else if (!showit)
+                       if (match == 0)

                                continue;
                                continue;

-                       else if (showit == 2)
-                               all_interesting = 1;

                }
 
                if (S_ISDIR(entry.mode))
                }
 
                if (S_ISDIR(entry.mode))

diff --git a/tree-diff.c b/tree-diff.c
index 3954281f509bbed9a9b095ed92d24b67275fed82..f291069bc3ab64158064a46fb25633e6347121e7 100644 (file)
--- a/tree-diff.c
+++ b/tree-diff.c
@@ -65,23 +65,17 @@ static int compare_tree_entry(struct tree_desc *t1, struct tree_desc *t2,
 static void show_tree(struct diff_options *opt, const char *prefix,
                      struct tree_desc *desc, struct strbuf *base)
 {
 static void show_tree(struct diff_options *opt, const char *prefix,
                      struct tree_desc *desc, struct strbuf *base)
 {

-       int all_interesting = 0;
-       while (desc->size) {
-               int show;
-
-               if (all_interesting)
-                       show = 1;
-               else {
-                       show = tree_entry_interesting(&desc->entry, base, 0,
-                                                     &opt->pathspec);
-                       if (show == 2)
-                               all_interesting = 1;
+       int match = 0;
+       for (; desc->size; update_tree_entry(desc)) {
+               if (match != 2) {
+                       match = tree_entry_interesting(&desc->entry, base, 0,
+                                                      &opt->pathspec);
+                       if (match < 0)
+                               break;
+                       if (match == 0)
+                               continue;

                }
                }

-               if (show < 0)
-                       break;
-               if (show)
-                       show_entry(opt, prefix, desc, base);
-               update_tree_entry(desc);
+               show_entry(opt, prefix, desc, base);

        }
 }
 
        }
 }
 


@@ -121,20 +115,16 @@ static void show_entry(struct diff_options *opt, const char *prefix,
 }
 
 static void skip_uninteresting(struct tree_desc *t, struct strbuf *base,
 }
 
 static void skip_uninteresting(struct tree_desc *t, struct strbuf *base,

-                              struct diff_options *opt, int *all_interesting)
+                              struct diff_options *opt, int *match)

 {
        while (t->size) {
 {
        while (t->size) {

-               int show = tree_entry_interesting(&t->entry, base, 0, &opt->pathspec);
-               if (show == 2)
-                       *all_interesting = 1;
-               if (!show) {
-                       update_tree_entry(t);
-                       continue;
+               *match = tree_entry_interesting(&t->entry, base, 0, &opt->pathspec);
+               if (*match) {
+                       if (*match < 0)
+                               t->size = 0;
+                       break;

                }
                }

-               /* Skip it all? */
-               if (show < 0)
-                       t->size = 0;
-               return;
+               update_tree_entry(t);

        }
 }
 
        }
 }
 


@@ -143,8 +133,7 @@ int diff_tree(struct tree_desc *t1, struct tree_desc *t2,
 {
        struct strbuf base;
        int baselen = strlen(base_str);
 {
        struct strbuf base;
        int baselen = strlen(base_str);

-       int all_t1_interesting = 0;
-       int all_t2_interesting = 0;
+       int t1_match = 0, t2_match = 0;

 
        /* Enable recursion indefinitely */
        opt->pathspec.recursive = DIFF_OPT_TST(opt, RECURSIVE);
 
        /* Enable recursion indefinitely */
        opt->pathspec.recursive = DIFF_OPT_TST(opt, RECURSIVE);


@@ -158,10 +147,8 @@ int diff_tree(struct tree_desc *t1, struct tree_desc *t2,
                    DIFF_OPT_TST(opt, HAS_CHANGES))
                        break;
                if (opt->pathspec.nr) {
                    DIFF_OPT_TST(opt, HAS_CHANGES))
                        break;
                if (opt->pathspec.nr) {

-                       if (!all_t1_interesting)
-                               skip_uninteresting(t1, &base, opt, &all_t1_interesting);
-                       if (!all_t2_interesting)
-                               skip_uninteresting(t2, &base, opt, &all_t2_interesting);
+                       skip_uninteresting(t1, &base, opt, &t1_match);
+                       skip_uninteresting(t2, &base, opt, &t2_match);

                }
                if (!t1->size) {
                        if (!t2->size)
                }
                if (!t1->size) {
                        if (!t2->size)