branch.c: use 'ref-filter' data structures

Make 'branch.c' use 'ref-filter' data structures and make changes to
support the new data structures. This is a part of the process of
porting 'branch.c' to use 'ref-filter' APIs.

This is a temporary step before porting 'branch.c' to use 'ref-filter'
completely. As this is a temporary step, most of the code introduced
here will be removed when 'branch.c' is ported over to use
'ref-filter' APIs.

Mentored-by: Christian Couder <christian.couder@gmail.com>
Mentored-by: Matthieu Moy <matthieu.moy@grenoble-inp.fr>
Signed-off-by: Karthik Nayak <karthik.188@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/branch.c b/builtin/branch.c
index ebc37423abb0fdccef84e1a373ed100455bbc32d..bfbba2f8d10501348e1ddf04a3928ab11cfb93f2 100644 (file)
--- a/builtin/branch.c
+++ b/builtin/branch.c
@@ -19,6 +19,7 @@
 #include "column.h"
 #include "utf8.h"
 #include "wt-status.h"
 #include "column.h"
 #include "utf8.h"
 #include "wt-status.h"

+#include "ref-filter.h"

 
 static const char * const builtin_branch_usage[] = {
        N_("git branch [<options>] [-r | -a] [--merged | --no-merged]"),
 
 static const char * const builtin_branch_usage[] = {
        N_("git branch [<options>] [-r | -a] [--merged | --no-merged]"),


@@ -28,10 +29,6 @@ static const char * const builtin_branch_usage[] = {
        NULL
 };
 
        NULL
 };
 

-#define REF_DETACHED_HEAD   0x01
-#define REF_LOCAL_BRANCH    0x02
-#define REF_REMOTE_BRANCH   0x04
-

 static const char *head;
 static unsigned char head_sha1[20];
 
 static const char *head;
 static unsigned char head_sha1[20];
 


@@ -53,13 +50,6 @@ enum color_branch {
        BRANCH_COLOR_UPSTREAM = 5
 };
 
        BRANCH_COLOR_UPSTREAM = 5
 };
 

-static enum merge_filter {
-       NO_FILTER = 0,
-       SHOW_NOT_MERGED,
-       SHOW_MERGED
-} merge_filter;
-static unsigned char merge_filter_ref[20];
-

 static struct string_list output = STRING_LIST_INIT_DUP;
 static unsigned int colopts;
 
 static struct string_list output = STRING_LIST_INIT_DUP;
 static unsigned int colopts;
 


@@ -122,7 +112,7 @@ static int branch_merged(int kind, const char *name,
        void *reference_name_to_free = NULL;
        int merged;
 
        void *reference_name_to_free = NULL;
        int merged;
 

-       if (kind == REF_LOCAL_BRANCH) {
+       if (kind == FILTER_REFS_BRANCHES) {

                struct branch *branch = branch_get(name);
                const char *upstream = branch_get_upstream(branch, NULL);
                unsigned char sha1[20];
                struct branch *branch = branch_get(name);
                const char *upstream = branch_get_upstream(branch, NULL);
                unsigned char sha1[20];


@@ -200,14 +190,14 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
        struct strbuf bname = STRBUF_INIT;
 
        switch (kinds) {
        struct strbuf bname = STRBUF_INIT;
 
        switch (kinds) {

-       case REF_REMOTE_BRANCH:
+       case FILTER_REFS_REMOTES:

                fmt = "refs/remotes/%s";
                /* For subsequent UI messages */
                remote_branch = 1;
 
                force = 1;
                break;
                fmt = "refs/remotes/%s";
                /* For subsequent UI messages */
                remote_branch = 1;
 
                force = 1;
                break;

-       case REF_LOCAL_BRANCH:
+       case FILTER_REFS_BRANCHES:

                fmt = "refs/heads/%s";
                break;
        default:
                fmt = "refs/heads/%s";
                break;
        default:


@@ -224,7 +214,7 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
                int flags = 0;
 
                strbuf_branchname(&bname, argv[i]);
                int flags = 0;
 
                strbuf_branchname(&bname, argv[i]);

-               if (kinds == REF_LOCAL_BRANCH && !strcmp(head, bname.buf)) {
+               if (kinds == FILTER_REFS_BRANCHES && !strcmp(head, bname.buf)) {

                        error(_("Cannot delete the branch '%s' "
                              "which you are currently on."), bname.buf);
                        ret = 1;
                        error(_("Cannot delete the branch '%s' "
                              "which you are currently on."), bname.buf);
                        ret = 1;


@@ -280,22 +270,6 @@ static int delete_branches(int argc, const char **argv, int force, int kinds,
        return(ret);
 }
 
        return(ret);
 }
 

-struct ref_item {
-       char *name;
-       char *dest;
-       unsigned int kind;
-       struct commit *commit;
-       int ignore;
-};
-
-struct ref_list {
-       struct rev_info revs;
-       int index, alloc, verbose, abbrev;
-       struct ref_item *list;
-       struct commit_list *with_commit;
-       int kinds;
-};
-

 static char *resolve_symref(const char *src, const char *prefix)
 {
        unsigned char sha1[20];
 static char *resolve_symref(const char *src, const char *prefix)
 {
        unsigned char sha1[20];


@@ -310,11 +284,6 @@ static char *resolve_symref(const char *src, const char *prefix)
        return xstrdup(dst);
 }
 
        return xstrdup(dst);
 }
 

-struct append_ref_cb {
-       struct ref_list *ref_list;
-       const char **pattern;
-};
-

 static int match_patterns(const char **pattern, const char *refname)
 {
        if (!*pattern)
 static int match_patterns(const char **pattern, const char *refname)
 {
        if (!*pattern)


@@ -327,11 +296,29 @@ static int match_patterns(const char **pattern, const char *refname)
        return 0;
 }
 
        return 0;
 }
 

+/*
+ * Allocate memory for a new ref_array_item and insert that into the
+ * given ref_array. Doesn't take the objectname unlike
+ * new_ref_array_item(). This is a temporary function which will be
+ * removed when we port branch.c to use ref-filter APIs.
+ */
+static struct ref_array_item *ref_array_append(struct ref_array *array, const char *refname)
+{
+       size_t len = strlen(refname);
+       struct ref_array_item *ref = xcalloc(1, sizeof(struct ref_array_item) + len + 1);
+       memcpy(ref->refname, refname, len);
+       ref->refname[len] = '\0';
+       REALLOC_ARRAY(array->items, array->nr + 1);
+       array->items[array->nr++] = ref;
+       return ref;
+}
+

 static int append_ref(const char *refname, const struct object_id *oid, int flags, void *cb_data)
 {
 static int append_ref(const char *refname, const struct object_id *oid, int flags, void *cb_data)
 {

-       struct append_ref_cb *cb = (struct append_ref_cb *)(cb_data);
-       struct ref_list *ref_list = cb->ref_list;
-       struct ref_item *newitem;
+       struct ref_filter_cbdata *cb = (struct ref_filter_cbdata *)(cb_data);
+       struct ref_filter *filter = cb->filter;
+       struct ref_array *array = cb->array;
+       struct ref_array_item *item;

        struct commit *commit;
        int kind, i;
        const char *prefix, *orig_refname = refname;
        struct commit *commit;
        int kind, i;
        const char *prefix, *orig_refname = refname;


@@ -340,8 +327,8 @@ static int append_ref(const char *refname, const struct object_id *oid, int flag
                int kind;
                const char *prefix;
        } ref_kind[] = {
                int kind;
                const char *prefix;
        } ref_kind[] = {

-               { REF_LOCAL_BRANCH, "refs/heads/" },
-               { REF_REMOTE_BRANCH, "refs/remotes/" },
+               { FILTER_REFS_BRANCHES, "refs/heads/" },
+               { FILTER_REFS_REMOTES, "refs/remotes/" },

        };
 
        /* Detect kind */
        };
 
        /* Detect kind */


@@ -354,65 +341,52 @@ static int append_ref(const char *refname, const struct object_id *oid, int flag
        }
        if (ARRAY_SIZE(ref_kind) <= i) {
                if (!strcmp(refname, "HEAD"))
        }
        if (ARRAY_SIZE(ref_kind) <= i) {
                if (!strcmp(refname, "HEAD"))

-                       kind = REF_DETACHED_HEAD;
+                       kind = FILTER_REFS_DETACHED_HEAD;

                else
                        return 0;
        }
 
        /* Don't add types the caller doesn't want */
                else
                        return 0;
        }
 
        /* Don't add types the caller doesn't want */

-       if ((kind & ref_list->kinds) == 0)
+       if ((kind & filter->kind) == 0)

                return 0;
 
                return 0;
 

-       if (!match_patterns(cb->pattern, refname))
+       if (!match_patterns(filter->name_patterns, refname))

                return 0;
 
        commit = NULL;
                return 0;
 
        commit = NULL;

-       if (ref_list->verbose || ref_list->with_commit || merge_filter != NO_FILTER) {
+       if (filter->verbose || filter->with_commit || filter->merge != REF_FILTER_MERGED_NONE) {

                commit = lookup_commit_reference_gently(oid->hash, 1);
                if (!commit)
                        return 0;
 
                /* Filter with with_commit if specified */
                commit = lookup_commit_reference_gently(oid->hash, 1);
                if (!commit)
                        return 0;
 
                /* Filter with with_commit if specified */

-               if (!is_descendant_of(commit, ref_list->with_commit))
+               if (!is_descendant_of(commit, filter->with_commit))

                        return 0;
 
                        return 0;
 

-               if (merge_filter != NO_FILTER)
-                       add_pending_object(&ref_list->revs,
+               if (filter->merge != REF_FILTER_MERGED_NONE)
+                       add_pending_object(array->revs,

                                           (struct object *)commit, refname);
        }
 
                                           (struct object *)commit, refname);
        }
 

-       ALLOC_GROW(ref_list->list, ref_list->index + 1, ref_list->alloc);
+       item = ref_array_append(array, refname);

 
        /* Record the new item */
 
        /* Record the new item */

-       newitem = &(ref_list->list[ref_list->index++]);
-       newitem->name = xstrdup(refname);
-       newitem->kind = kind;
-       newitem->commit = commit;
-       newitem->dest = resolve_symref(orig_refname, prefix);
-       newitem->ignore = 0;
+       item->kind = kind;
+       item->commit = commit;
+       item->symref = resolve_symref(orig_refname, prefix);
+       item->ignore = 0;

 
        return 0;
 }
 
 
        return 0;
 }
 

-static void free_ref_list(struct ref_list *ref_list)
-{
-       int i;
-
-       for (i = 0; i < ref_list->index; i++) {
-               free(ref_list->list[i].name);
-               free(ref_list->list[i].dest);
-       }
-       free(ref_list->list);
-}
-

 static int ref_cmp(const void *r1, const void *r2)
 {
 static int ref_cmp(const void *r1, const void *r2)
 {

-       struct ref_item *c1 = (struct ref_item *)(r1);
-       struct ref_item *c2 = (struct ref_item *)(r2);
+       struct ref_array_item *c1 = *((struct ref_array_item **)r1);
+       struct ref_array_item *c2 = *((struct ref_array_item **)r2);

 
        if (c1->kind != c2->kind)
                return c1->kind - c2->kind;
 
        if (c1->kind != c2->kind)
                return c1->kind - c2->kind;

-       return strcmp(c1->name, c2->name);
+       return strcmp(c1->refname, c2->refname);

 }
 
 static void fill_tracking_info(struct strbuf *stat, const char *branch_name,
 }
 
 static void fill_tracking_info(struct strbuf *stat, const char *branch_name,


@@ -477,8 +451,8 @@ static void fill_tracking_info(struct strbuf *stat, const char *branch_name,
        free(ref);
 }
 
        free(ref);
 }
 

-static void add_verbose_info(struct strbuf *out, struct ref_item *item,
-                            int verbose, int abbrev)
+static void add_verbose_info(struct strbuf *out, struct ref_array_item *item,
+                            struct ref_filter *filter)

 {
        struct strbuf subject = STRBUF_INIT, stat = STRBUF_INIT;
        const char *sub = _(" **** invalid ref ****");
 {
        struct strbuf subject = STRBUF_INIT, stat = STRBUF_INIT;
        const char *sub = _(" **** invalid ref ****");


@@ -489,11 +463,11 @@ static void add_verbose_info(struct strbuf *out, struct ref_item *item,
                sub = subject.buf;
        }
 
                sub = subject.buf;
        }
 

-       if (item->kind == REF_LOCAL_BRANCH)
-               fill_tracking_info(&stat, item->name, verbose > 1);
+       if (item->kind == FILTER_REFS_BRANCHES)
+               fill_tracking_info(&stat, item->refname, filter->verbose > 1);

 
        strbuf_addf(out, " %s %s%s",
 
        strbuf_addf(out, " %s %s%s",

-               find_unique_abbrev(item->commit->object.sha1, abbrev),
+               find_unique_abbrev(item->commit->object.sha1, filter->abbrev),

                stat.buf, sub);
        strbuf_release(&stat);
        strbuf_release(&subject);
                stat.buf, sub);
        strbuf_release(&stat);
        strbuf_release(&subject);


@@ -530,32 +504,32 @@ static char *get_head_description(void)
        return strbuf_detach(&desc, NULL);
 }
 
        return strbuf_detach(&desc, NULL);
 }
 

-static void print_ref_item(struct ref_item *item, int maxwidth, int verbose,
-                          int abbrev, int detached, const char *remote_prefix)
+static void print_ref_item(struct ref_array_item *item, int maxwidth,
+                          struct ref_filter *filter, const char *remote_prefix)

 {
        char c;
        int current = 0;
        int color;
        struct strbuf out = STRBUF_INIT, name = STRBUF_INIT;
        const char *prefix = "";
 {
        char c;
        int current = 0;
        int color;
        struct strbuf out = STRBUF_INIT, name = STRBUF_INIT;
        const char *prefix = "";

-       const char *desc = item->name;
+       const char *desc = item->refname;

        char *to_free = NULL;
 
        if (item->ignore)
                return;
 
        switch (item->kind) {
        char *to_free = NULL;
 
        if (item->ignore)
                return;
 
        switch (item->kind) {

-       case REF_LOCAL_BRANCH:
-               if (!detached && !strcmp(item->name, head))
+       case FILTER_REFS_BRANCHES:
+               if (!filter->detached && !strcmp(item->refname, head))

                        current = 1;
                else
                        color = BRANCH_COLOR_LOCAL;
                break;
                        current = 1;
                else
                        color = BRANCH_COLOR_LOCAL;
                break;

-       case REF_REMOTE_BRANCH:
+       case FILTER_REFS_REMOTES:

                color = BRANCH_COLOR_REMOTE;
                prefix = remote_prefix;
                break;
                color = BRANCH_COLOR_REMOTE;
                prefix = remote_prefix;
                break;

-       case REF_DETACHED_HEAD:
+       case FILTER_REFS_DETACHED_HEAD:

                desc = to_free = get_head_description();
                current = 1;
                break;
                desc = to_free = get_head_description();
                current = 1;
                break;


@@ -571,7 +545,7 @@ static void print_ref_item(struct ref_item *item, int maxwidth, int verbose,
        }
 
        strbuf_addf(&name, "%s%s", prefix, desc);
        }
 
        strbuf_addf(&name, "%s%s", prefix, desc);

-       if (verbose) {
+       if (filter->verbose) {

                int utf8_compensation = strlen(name.buf) - utf8_strwidth(name.buf);
                strbuf_addf(&out, "%c %s%-*s%s", c, branch_get_color(color),
                            maxwidth + utf8_compensation, name.buf,
                int utf8_compensation = strlen(name.buf) - utf8_strwidth(name.buf);
                strbuf_addf(&out, "%c %s%-*s%s", c, branch_get_color(color),
                            maxwidth + utf8_compensation, name.buf,


@@ -580,13 +554,13 @@ static void print_ref_item(struct ref_item *item, int maxwidth, int verbose,
                strbuf_addf(&out, "%c %s%s%s", c, branch_get_color(color),
                            name.buf, branch_get_color(BRANCH_COLOR_RESET));
 
                strbuf_addf(&out, "%c %s%s%s", c, branch_get_color(color),
                            name.buf, branch_get_color(BRANCH_COLOR_RESET));
 

-       if (item->dest)
-               strbuf_addf(&out, " -> %s", item->dest);
-       else if (verbose)
+       if (item->symref)
+               strbuf_addf(&out, " -> %s", item->symref);
+       else if (filter->verbose)

                /* " f7c0c00 [ahead 58, behind 197] vcs-svn: drop obj_pool.h" */
                /* " f7c0c00 [ahead 58, behind 197] vcs-svn: drop obj_pool.h" */

-               add_verbose_info(&out, item, verbose, abbrev);
+               add_verbose_info(&out, item, filter);

        if (column_active(colopts)) {
        if (column_active(colopts)) {

-               assert(!verbose && "--column and --verbose are incompatible");
+               assert(!filter->verbose && "--column and --verbose are incompatible");

                string_list_append(&output, out.buf);
        } else {
                printf("%s\n", out.buf);
                string_list_append(&output, out.buf);
        } else {
                printf("%s\n", out.buf);


@@ -596,17 +570,17 @@ static void print_ref_item(struct ref_item *item, int maxwidth, int verbose,
        free(to_free);
 }
 
        free(to_free);
 }
 

-static int calc_maxwidth(struct ref_list *refs, int remote_bonus)
+static int calc_maxwidth(struct ref_array *refs, int remote_bonus)

 {
        int i, max = 0;
 {
        int i, max = 0;

-       for (i = 0; i < refs->index; i++) {
-               struct ref_item *it = &refs->list[i];
+       for (i = 0; i < refs->nr; i++) {
+               struct ref_array_item *it = refs->items[i];

                int w;
 
                if (it->ignore)
                        continue;
                int w;
 
                if (it->ignore)
                        continue;

-               w = utf8_strwidth(it->name);
-               if (it->kind == REF_REMOTE_BRANCH)
+               w = utf8_strwidth(it->refname);
+               if (it->kind == FILTER_REFS_REMOTES)

                        w += remote_bonus;
                if (w > max)
                        max = w;
                        w += remote_bonus;
                if (w > max)
                        max = w;


@@ -614,81 +588,74 @@ static int calc_maxwidth(struct ref_list *refs, int remote_bonus)
        return max;
 }
 
        return max;
 }
 

-static void print_ref_list(int kinds, int detached, int verbose, int abbrev, struct commit_list *with_commit, const char **pattern)
+static void print_ref_list(struct ref_filter *filter)

 {
        int i;
 {
        int i;

-       struct append_ref_cb cb;
-       struct ref_list ref_list;
+       struct ref_array array;
+       struct ref_filter_cbdata data;

        int maxwidth = 0;
        const char *remote_prefix = "";
        int maxwidth = 0;
        const char *remote_prefix = "";

+       struct rev_info revs;

 
        /*
         * If we are listing more than just remote branches,
         * then remote branches will have a "remotes/" prefix.
         * We need to account for this in the width.
         */
 
        /*
         * If we are listing more than just remote branches,
         * then remote branches will have a "remotes/" prefix.
         * We need to account for this in the width.
         */

-       if (kinds != REF_REMOTE_BRANCH)
+       if (filter->kind != FILTER_REFS_REMOTES)

                remote_prefix = "remotes/";
 
                remote_prefix = "remotes/";
 

-       memset(&ref_list, 0, sizeof(ref_list));
-       ref_list.kinds = kinds;
-       ref_list.verbose = verbose;
-       ref_list.abbrev = abbrev;
-       ref_list.with_commit = with_commit;
-       if (merge_filter != NO_FILTER)
-               init_revisions(&ref_list.revs, NULL);
-       cb.ref_list = &ref_list;
-       cb.pattern = pattern;
+       memset(&array, 0, sizeof(array));
+       if (filter->merge != REF_FILTER_MERGED_NONE)
+               init_revisions(&revs, NULL);
+
+       data.array = &array;
+       data.filter = filter;
+       array.revs = &revs;
+

        /*
         * First we obtain all regular branch refs and if the HEAD is
         * detached then we insert that ref to the end of the ref_fist
         * so that it can be printed and removed first.
         */
        /*
         * First we obtain all regular branch refs and if the HEAD is
         * detached then we insert that ref to the end of the ref_fist
         * so that it can be printed and removed first.
         */

-       for_each_rawref(append_ref, &cb);
-       if (detached)
-               head_ref(append_ref, &cb);
+       for_each_rawref(append_ref, &data);
+       if (filter->detached)
+               head_ref(append_ref, &data);

        /*
         * The following implementation is currently duplicated in ref-filter. It
         * will eventually be removed when we port branch.c to use ref-filter APIs.
         */
        /*
         * The following implementation is currently duplicated in ref-filter. It
         * will eventually be removed when we port branch.c to use ref-filter APIs.
         */

-       if (merge_filter != NO_FILTER) {
-               struct commit *filter;
-               filter = lookup_commit_reference_gently(merge_filter_ref, 0);
-               if (!filter)
-                       die(_("object '%s' does not point to a commit"),
-                           sha1_to_hex(merge_filter_ref));
-
-               filter->object.flags |= UNINTERESTING;
-               add_pending_object(&ref_list.revs,
-                                  (struct object *) filter, "");
-               ref_list.revs.limited = 1;
-
-               if (prepare_revision_walk(&ref_list.revs))
+       if (filter->merge != REF_FILTER_MERGED_NONE) {
+               filter->merge_commit->object.flags |= UNINTERESTING;
+               add_pending_object(&revs, &filter->merge_commit->object, "");
+               revs.limited = 1;
+
+               if (prepare_revision_walk(&revs))

                        die(_("revision walk setup failed"));
 
                        die(_("revision walk setup failed"));
 

-               for (i = 0; i < ref_list.index; i++) {
-                       struct ref_item *item = &ref_list.list[i];
+               for (i = 0; i < array.nr; i++) {
+                       struct ref_array_item *item = array.items[i];

                        struct commit *commit = item->commit;
                        int is_merged = !!(commit->object.flags & UNINTERESTING);
                        struct commit *commit = item->commit;
                        int is_merged = !!(commit->object.flags & UNINTERESTING);

-                       item->ignore = is_merged != (merge_filter == SHOW_MERGED);
+                       item->ignore = is_merged != (filter->merge == REF_FILTER_MERGED_INCLUDE);

                }
 
                }
 

-               for (i = 0; i < ref_list.index; i++) {
-                       struct ref_item *item = &ref_list.list[i];
+               for (i = 0; i < array.nr; i++) {
+                       struct ref_array_item *item = array.items[i];

                        clear_commit_marks(item->commit, ALL_REV_FLAGS);
                }
                        clear_commit_marks(item->commit, ALL_REV_FLAGS);
                }

-               clear_commit_marks(filter, ALL_REV_FLAGS);
+               clear_commit_marks(filter->merge_commit, ALL_REV_FLAGS);

        }
        }

-       if (verbose)
-               maxwidth = calc_maxwidth(&ref_list, strlen(remote_prefix));

 
 

-       qsort(ref_list.list, ref_list.index, sizeof(struct ref_item), ref_cmp);
+       if (filter->verbose)
+               maxwidth = calc_maxwidth(&array, strlen(remote_prefix));
+
+       qsort(array.items, array.nr, sizeof(struct ref_array_item *), ref_cmp);

 
 

-       for (i = 0; i < ref_list.index; i++)
-               print_ref_item(&ref_list.list[i], maxwidth, verbose,
-                              abbrev, detached, remote_prefix);
+       for (i = 0; i < array.nr; i++)
+               print_ref_item(array.items[i], maxwidth, filter, remote_prefix);

 
 

-       free_ref_list(&ref_list);
+       ref_array_clear(&array);

 }
 
 static void rename_branch(const char *oldname, const char *newname, int force)
 }
 
 static void rename_branch(const char *oldname, const char *newname, int force)


@@ -744,24 +711,6 @@ static void rename_branch(const char *oldname, const char *newname, int force)
        strbuf_release(&newsection);
 }
 
        strbuf_release(&newsection);
 }
 

-/*
- * This function is duplicated in ref-filter. It will eventually be removed
- * when we port branch.c to use ref-filter APIs.
- */
-static int opt_parse_merge_filter(const struct option *opt, const char *arg, int unset)
-{
-       merge_filter = ((opt->long_name[0] == 'n')
-                       ? SHOW_NOT_MERGED
-                       : SHOW_MERGED);
-       if (unset)
-               merge_filter = SHOW_NOT_MERGED; /* b/c for --no-merged */
-       if (!arg)
-               arg = "HEAD";
-       if (get_sha1(arg, merge_filter_ref))
-               die(_("malformed object name %s"), arg);
-       return 0;
-}
-

 static const char edit_description[] = "BRANCH_DESCRIPTION";
 
 static int edit_branch_description(const char *branch_name)
 static const char edit_description[] = "BRANCH_DESCRIPTION";
 
 static int edit_branch_description(const char *branch_name)


@@ -801,17 +750,15 @@ static int edit_branch_description(const char *branch_name)
 int cmd_branch(int argc, const char **argv, const char *prefix)
 {
        int delete = 0, rename = 0, force = 0, list = 0;
 int cmd_branch(int argc, const char **argv, const char *prefix)
 {
        int delete = 0, rename = 0, force = 0, list = 0;

-       int verbose = 0, abbrev = -1, detached = 0;

        int reflog = 0, edit_description = 0;
        int quiet = 0, unset_upstream = 0;
        const char *new_upstream = NULL;
        enum branch_track track;
        int reflog = 0, edit_description = 0;
        int quiet = 0, unset_upstream = 0;
        const char *new_upstream = NULL;
        enum branch_track track;

-       int kinds = REF_LOCAL_BRANCH;
-       struct commit_list *with_commit = NULL;
+       struct ref_filter filter;

 
        struct option options[] = {
                OPT_GROUP(N_("Generic options")),
 
        struct option options[] = {
                OPT_GROUP(N_("Generic options")),

-               OPT__VERBOSE(&verbose,
+               OPT__VERBOSE(&filter.verbose,

                        N_("show hash and subject, give twice for upstream branch")),
                OPT__QUIET(&quiet, N_("suppress informational messages")),
                OPT_SET_INT('t', "track",  &track, N_("set up tracking mode (see git-pull(1))"),
                        N_("show hash and subject, give twice for upstream branch")),
                OPT__QUIET(&quiet, N_("suppress informational messages")),
                OPT_SET_INT('t', "track",  &track, N_("set up tracking mode (see git-pull(1))"),


@@ -821,15 +768,15 @@ int cmd_branch(int argc, const char **argv, const char *prefix)
                OPT_STRING('u', "set-upstream-to", &new_upstream, "upstream", "change the upstream info"),
                OPT_BOOL(0, "unset-upstream", &unset_upstream, "Unset the upstream info"),
                OPT__COLOR(&branch_use_color, N_("use colored output")),
                OPT_STRING('u', "set-upstream-to", &new_upstream, "upstream", "change the upstream info"),
                OPT_BOOL(0, "unset-upstream", &unset_upstream, "Unset the upstream info"),
                OPT__COLOR(&branch_use_color, N_("use colored output")),

-               OPT_SET_INT('r', "remotes",     &kinds, N_("act on remote-tracking branches"),
-                       REF_REMOTE_BRANCH),
-               OPT_CONTAINS(&with_commit, N_("print only branches that contain the commit")),
-               OPT_WITH(&with_commit, N_("print only branches that contain the commit")),
-               OPT__ABBREV(&abbrev),
+               OPT_SET_INT('r', "remotes",     &filter.kind, N_("act on remote-tracking branches"),
+                       FILTER_REFS_REMOTES),
+               OPT_CONTAINS(&filter.with_commit, N_("print only branches that contain the commit")),
+               OPT_WITH(&filter.with_commit, N_("print only branches that contain the commit")),
+               OPT__ABBREV(&filter.abbrev),

 
                OPT_GROUP(N_("Specific git-branch actions:")),
 
                OPT_GROUP(N_("Specific git-branch actions:")),

-               OPT_SET_INT('a', "all", &kinds, N_("list both remote-tracking and local branches"),
-                       REF_REMOTE_BRANCH | REF_LOCAL_BRANCH),
+               OPT_SET_INT('a', "all", &filter.kind, N_("list both remote-tracking and local branches"),
+                       FILTER_REFS_REMOTES | FILTER_REFS_BRANCHES),

                OPT_BIT('d', "delete", &delete, N_("delete fully merged branch"), 1),
                OPT_BIT('D', NULL, &delete, N_("delete branch (even if not merged)"), 2),
                OPT_BIT('m', "move", &rename, N_("move/rename a branch and its reflog"), 1),
                OPT_BIT('d', "delete", &delete, N_("delete fully merged branch"), 1),
                OPT_BIT('D', NULL, &delete, N_("delete branch (even if not merged)"), 2),
                OPT_BIT('m', "move", &rename, N_("move/rename a branch and its reflog"), 1),


@@ -839,22 +786,16 @@ int cmd_branch(int argc, const char **argv, const char *prefix)
                OPT_BOOL(0, "edit-description", &edit_description,
                         N_("edit the description for the branch")),
                OPT__FORCE(&force, N_("force creation, move/rename, deletion")),
                OPT_BOOL(0, "edit-description", &edit_description,
                         N_("edit the description for the branch")),
                OPT__FORCE(&force, N_("force creation, move/rename, deletion")),

-               {
-                       OPTION_CALLBACK, 0, "no-merged", &merge_filter_ref,
-                       N_("commit"), N_("print only not merged branches"),
-                       PARSE_OPT_LASTARG_DEFAULT | PARSE_OPT_NONEG,
-                       opt_parse_merge_filter, (intptr_t) "HEAD",
-               },
-               {
-                       OPTION_CALLBACK, 0, "merged", &merge_filter_ref,
-                       N_("commit"), N_("print only merged branches"),
-                       PARSE_OPT_LASTARG_DEFAULT | PARSE_OPT_NONEG,
-                       opt_parse_merge_filter, (intptr_t) "HEAD",
-               },
+               OPT_MERGED(&filter, N_("print only branches that are merged")),
+               OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),

                OPT_COLUMN(0, "column", &colopts, N_("list branches in columns")),
                OPT_END(),
        };
 
                OPT_COLUMN(0, "column", &colopts, N_("list branches in columns")),
                OPT_END(),
        };
 

+       memset(&filter, 0, sizeof(filter));
+       filter.kind = FILTER_REFS_BRANCHES;
+       filter.abbrev = -1;
+

        if (argc == 2 && !strcmp(argv[1], "-h"))
                usage_with_options(builtin_branch_usage, options);
 
        if (argc == 2 && !strcmp(argv[1], "-h"))
                usage_with_options(builtin_branch_usage, options);
 


@@ -866,11 +807,9 @@ int cmd_branch(int argc, const char **argv, const char *prefix)
        if (!head)
                die(_("Failed to resolve HEAD as a valid ref."));
        if (!strcmp(head, "HEAD"))
        if (!head)
                die(_("Failed to resolve HEAD as a valid ref."));
        if (!strcmp(head, "HEAD"))

-               detached = 1;
+               filter.detached = 1;

        else if (!skip_prefix(head, "refs/heads/", &head))
                die(_("HEAD not found below refs/heads!"));
        else if (!skip_prefix(head, "refs/heads/", &head))
                die(_("HEAD not found below refs/heads!"));

-       hashcpy(merge_filter_ref, head_sha1);
-

 
        argc = parse_options(argc, argv, prefix, options, builtin_branch_usage,
                             0);
 
        argc = parse_options(argc, argv, prefix, options, builtin_branch_usage,
                             0);


@@ -878,17 +817,17 @@ int cmd_branch(int argc, const char **argv, const char *prefix)
        if (!delete && !rename && !edit_description && !new_upstream && !unset_upstream && argc == 0)
                list = 1;
 
        if (!delete && !rename && !edit_description && !new_upstream && !unset_upstream && argc == 0)
                list = 1;
 

-       if (with_commit || merge_filter != NO_FILTER)
+       if (filter.with_commit || filter.merge != REF_FILTER_MERGED_NONE)

                list = 1;
 
        if (!!delete + !!rename + !!new_upstream +
            list + unset_upstream > 1)
                usage_with_options(builtin_branch_usage, options);
 
                list = 1;
 
        if (!!delete + !!rename + !!new_upstream +
            list + unset_upstream > 1)
                usage_with_options(builtin_branch_usage, options);
 

-       if (abbrev == -1)
-               abbrev = DEFAULT_ABBREV;
+       if (filter.abbrev == -1)
+               filter.abbrev = DEFAULT_ABBREV;

        finalize_colopts(&colopts, -1);
        finalize_colopts(&colopts, -1);

-       if (verbose) {
+       if (filter.verbose) {

                if (explicitly_enable_column(colopts))
                        die(_("--column and --verbose are incompatible"));
                colopts = 0;
                if (explicitly_enable_column(colopts))
                        die(_("--column and --verbose are incompatible"));
                colopts = 0;


@@ -902,13 +841,13 @@ int cmd_branch(int argc, const char **argv, const char *prefix)
        if (delete) {
                if (!argc)
                        die(_("branch name required"));
        if (delete) {
                if (!argc)
                        die(_("branch name required"));

-               return delete_branches(argc, argv, delete > 1, kinds, quiet);
+               return delete_branches(argc, argv, delete > 1, filter.kind, quiet);

        } else if (list) {
                /*  git branch --local also shows HEAD when it is detached */
        } else if (list) {
                /*  git branch --local also shows HEAD when it is detached */

-               if (kinds & REF_LOCAL_BRANCH)
-                       kinds |= REF_DETACHED_HEAD;
-               print_ref_list(kinds, detached, verbose, abbrev,
-                                        with_commit, argv);
+               if ((filter.kind & FILTER_REFS_BRANCHES) && filter.detached)
+                       filter.kind |= FILTER_REFS_DETACHED_HEAD;
+               filter.name_patterns = argv;
+               print_ref_list(&filter);

                print_columns(&output, colopts, NULL);
                string_list_clear(&output, 0);
                return 0;
                print_columns(&output, colopts, NULL);
                string_list_clear(&output, 0);
                return 0;


@@ -918,7 +857,7 @@ int cmd_branch(int argc, const char **argv, const char *prefix)
                struct strbuf branch_ref = STRBUF_INIT;
 
                if (!argc) {
                struct strbuf branch_ref = STRBUF_INIT;
 
                if (!argc) {

-                       if (detached)
+                       if (filter.detached)

                                die(_("Cannot give description to detached HEAD"));
                        branch_name = head;
                } else if (argc == 1)
                                die(_("Cannot give description to detached HEAD"));
                        branch_name = head;
                } else if (argc == 1)


@@ -1006,7 +945,7 @@ int cmd_branch(int argc, const char **argv, const char *prefix)
                if (!branch)
                        die(_("no such branch '%s'"), argv[0]);
 
                if (!branch)
                        die(_("no such branch '%s'"), argv[0]);
 

-               if (kinds != REF_LOCAL_BRANCH)
+               if (filter.kind != FILTER_REFS_BRANCHES)

                        die(_("-a and -r options to 'git branch' do not make sense with a branch name"));
 
                if (track == BRANCH_TRACK_OVERRIDE)
                        die(_("-a and -r options to 'git branch' do not make sense with a branch name"));
 
                if (track == BRANCH_TRACK_OVERRIDE)

diff --git a/ref-filter.h b/ref-filter.h
index a5cfa5e677dbdf17156c6287f57fa5694b9d5120..fadebc5da600320fff60f5c7c413f12bf7e1996b 100644 (file)
--- a/ref-filter.h
+++ b/ref-filter.h
@@ -36,6 +36,7 @@ struct ref_array_item {
        unsigned char objectname[20];
        int flag;
        unsigned int kind;
        unsigned char objectname[20];
        int flag;
        unsigned int kind;

+       int ignore : 1; /* To be removed in the next patch */

        const char *symref;
        struct commit *commit;
        struct atom_value *value;
        const char *symref;
        struct commit *commit;
        struct atom_value *value;


@@ -45,6 +46,7 @@ struct ref_array_item {
 struct ref_array {
        int nr, alloc;
        struct ref_array_item **items;
 struct ref_array {
        int nr, alloc;
        struct ref_array_item **items;

+       struct rev_info *revs;

 };
 
 struct ref_filter {
 };
 
 struct ref_filter {


@@ -60,9 +62,12 @@ struct ref_filter {
        struct commit *merge_commit;
 
        unsigned int with_commit_tag_algo : 1,
        struct commit *merge_commit;
 
        unsigned int with_commit_tag_algo : 1,

-               match_as_path : 1;
+               match_as_path : 1,
+               detached : 1;

        unsigned int kind,
                lines;
        unsigned int kind,
                lines;

+       int abbrev,
+               verbose;

 };
 
 struct ref_filter_cbdata {
 };
 
 struct ref_filter_cbdata {