repack_without_refs(): make the refnames argument a string_list

Most of the callers have string_lists available already, whereas two
of them had to read data out of a string_list into an array of strings
just to call this function. So change repack_without_refs() to take
the list of refnames to omit as a string_list, and change the callers
accordingly.

Suggested-by: Ronnie Sahlberg <sahlberg@google.com>
Signed-off-by: Michael Haggerty <mhagger@alum.mit.edu>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/remote.c b/builtin/remote.c
index 7d5c8d2074ba503601f45e3a0100c7f5326340cd..63a67098a074bd8df7d62e681b4608511b197373 100644 (file)
--- a/builtin/remote.c
+++ b/builtin/remote.c
@@ -750,16 +750,11 @@ static int mv(int argc, const char **argv)
 static int remove_branches(struct string_list *branches)
 {
        struct strbuf err = STRBUF_INIT;
 static int remove_branches(struct string_list *branches)
 {
        struct strbuf err = STRBUF_INIT;

-       const char **branch_names;

        int i, result = 0;
 
        int i, result = 0;
 

-       branch_names = xmalloc(branches->nr * sizeof(*branch_names));
-       for (i = 0; i < branches->nr; i++)
-               branch_names[i] = branches->items[i].string;
-       if (repack_without_refs(branch_names, branches->nr, &err))
+       if (repack_without_refs(branches, &err))

                result |= error("%s", err.buf);
        strbuf_release(&err);
                result |= error("%s", err.buf);
        strbuf_release(&err);

-       free(branch_names);

 
        for (i = 0; i < branches->nr; i++) {
                struct string_list_item *item = branches->items + i;
 
        for (i = 0; i < branches->nr; i++) {
                struct string_list_item *item = branches->items + i;


@@ -1317,7 +1312,6 @@ static int prune_remote(const char *remote, int dry_run)
        int result = 0, i;
        struct ref_states states;
        struct string_list delete_refs_list = STRING_LIST_INIT_NODUP;
        int result = 0, i;
        struct ref_states states;
        struct string_list delete_refs_list = STRING_LIST_INIT_NODUP;

-       const char **delete_refs;

        const char *dangling_msg = dry_run
                ? _(" %s will become dangling!")
                : _(" %s has become dangling!");
        const char *dangling_msg = dry_run
                ? _(" %s will become dangling!")
                : _(" %s has become dangling!");


@@ -1336,19 +1330,16 @@ static int prune_remote(const char *remote, int dry_run)
                  ? states.remote->url[0]
                  : _("(no URL)"));
 
                  ? states.remote->url[0]
                  : _("(no URL)"));
 

-       delete_refs = xmalloc(states.stale.nr * sizeof(*delete_refs));

        for (i = 0; i < states.stale.nr; i++) {
                const char *refname = states.stale.items[i].util;
 
        for (i = 0; i < states.stale.nr; i++) {
                const char *refname = states.stale.items[i].util;
 

-               delete_refs[i] = refname;

                string_list_append(&delete_refs_list, refname);
        }
        sort_string_list(&delete_refs_list);
 
        if (!dry_run) {
                struct strbuf err = STRBUF_INIT;
                string_list_append(&delete_refs_list, refname);
        }
        sort_string_list(&delete_refs_list);
 
        if (!dry_run) {
                struct strbuf err = STRBUF_INIT;

-               if (repack_without_refs(delete_refs, states.stale.nr,
-                                       &err))
+               if (repack_without_refs(&delete_refs_list, &err))

                        result |= error("%s", err.buf);
                strbuf_release(&err);
        }
                        result |= error("%s", err.buf);
                strbuf_release(&err);
        }


@@ -1369,7 +1360,6 @@ static int prune_remote(const char *remote, int dry_run)
 
        warn_dangling_symrefs(stdout, dangling_msg, &delete_refs_list);
 
 
        warn_dangling_symrefs(stdout, dangling_msg, &delete_refs_list);
 

-       free(delete_refs);

        string_list_clear(&delete_refs_list, 0);
        free_remote_ref_states(&states);
        return result;
        string_list_clear(&delete_refs_list, 0);
        free_remote_ref_states(&states);
        return result;

diff --git a/refs.c b/refs.c
index 5ff457ebfce7aba9cd470f3e2e1f3f5dbe9d9741..b675e013a941048f315cc88f836e91b8dc2f44a3 100644 (file)
--- a/refs.c
+++ b/refs.c
@@ -2639,22 +2639,25 @@ static int curate_packed_ref_fn(struct ref_entry *entry, void *cb_data)
        return 0;
 }
 
        return 0;
 }
 

-int repack_without_refs(const char **refnames, int n, struct strbuf *err)
+int repack_without_refs(struct string_list *refnames, struct strbuf *err)

 {
        struct ref_dir *packed;
        struct string_list refs_to_delete = STRING_LIST_INIT_DUP;
 {
        struct ref_dir *packed;
        struct string_list refs_to_delete = STRING_LIST_INIT_DUP;

-       struct string_list_item *ref_to_delete;
-       int i, ret, removed = 0;
+       struct string_list_item *refname, *ref_to_delete;
+       int ret, needs_repacking = 0, removed = 0;

 
        assert(err);
 
        /* Look for a packed ref */
 
        assert(err);
 
        /* Look for a packed ref */

-       for (i = 0; i < n; i++)
-               if (get_packed_ref(refnames[i]))
+       for_each_string_list_item(refname, refnames) {
+               if (get_packed_ref(refname->string)) {
+                       needs_repacking = 1;

                        break;
                        break;

+               }
+       }

 
        /* Avoid locking if we have nothing to do */
 
        /* Avoid locking if we have nothing to do */

-       if (i == n)
+       if (!needs_repacking)

                return 0; /* no refname exists in packed refs */
 
        if (lock_packed_refs(0)) {
                return 0; /* no refname exists in packed refs */
 
        if (lock_packed_refs(0)) {


@@ -2664,8 +2667,8 @@ int repack_without_refs(const char **refnames, int n, struct strbuf *err)
        packed = get_packed_refs(&ref_cache);
 
        /* Remove refnames from the cache */
        packed = get_packed_refs(&ref_cache);
 
        /* Remove refnames from the cache */

-       for (i = 0; i < n; i++)
-               if (remove_entry(packed, refnames[i]) != -1)
+       for_each_string_list_item(refname, refnames)
+               if (remove_entry(packed, refname->string) != -1)

                        removed = 1;
        if (!removed) {
                /*
                        removed = 1;
        if (!removed) {
                /*


@@ -3738,10 +3741,11 @@ static int ref_update_reject_duplicates(struct ref_update **updates, int n,
 int ref_transaction_commit(struct ref_transaction *transaction,
                           struct strbuf *err)
 {
 int ref_transaction_commit(struct ref_transaction *transaction,
                           struct strbuf *err)
 {

-       int ret = 0, delnum = 0, i;
-       const char **delnames;
+       int ret = 0, i;

        int n = transaction->nr;
        struct ref_update **updates = transaction->updates;
        int n = transaction->nr;
        struct ref_update **updates = transaction->updates;

+       struct string_list refs_to_delete = STRING_LIST_INIT_NODUP;
+       struct string_list_item *ref_to_delete;

 
        assert(err);
 
 
        assert(err);
 


@@ -3753,9 +3757,6 @@ int ref_transaction_commit(struct ref_transaction *transaction,
                return 0;
        }
 
                return 0;
        }
 

-       /* Allocate work space */
-       delnames = xmalloc(sizeof(*delnames) * n);
-

        /* Copy, sort, and reject duplicate refs */
        qsort(updates, n, sizeof(*updates), ref_update_compare);
        if (ref_update_reject_duplicates(updates, n, err)) {
        /* Copy, sort, and reject duplicate refs */
        qsort(updates, n, sizeof(*updates), ref_update_compare);
        if (ref_update_reject_duplicates(updates, n, err)) {


@@ -3815,16 +3816,17 @@ int ref_transaction_commit(struct ref_transaction *transaction,
                        }
 
                        if (!(update->flags & REF_ISPRUNING))
                        }
 
                        if (!(update->flags & REF_ISPRUNING))

-                               delnames[delnum++] = update->lock->ref_name;
+                               string_list_append(&refs_to_delete,
+                                                  update->lock->ref_name);

                }
        }
 
                }
        }
 

-       if (repack_without_refs(delnames, delnum, err)) {
+       if (repack_without_refs(&refs_to_delete, err)) {

                ret = TRANSACTION_GENERIC_ERROR;
                goto cleanup;
        }
                ret = TRANSACTION_GENERIC_ERROR;
                goto cleanup;
        }

-       for (i = 0; i < delnum; i++)
-               unlink_or_warn(git_path("logs/%s", delnames[i]));
+       for_each_string_list_item(ref_to_delete, &refs_to_delete)
+               unlink_or_warn(git_path("logs/%s", ref_to_delete->string));

        clear_loose_ref_cache(&ref_cache);
 
 cleanup:
        clear_loose_ref_cache(&ref_cache);
 
 cleanup:


@@ -3833,7 +3835,7 @@ int ref_transaction_commit(struct ref_transaction *transaction,
        for (i = 0; i < n; i++)
                if (updates[i]->lock)
                        unlock_ref(updates[i]->lock);
        for (i = 0; i < n; i++)
                if (updates[i]->lock)
                        unlock_ref(updates[i]->lock);

-       free(delnames);
+       string_list_clear(&refs_to_delete, 0);

        return ret;
 }
 
        return ret;
 }
 

diff --git a/refs.h b/refs.h
index 2bc3556874a7b1cbccb4cebf4e3dc2fa13cc780f..405c6572f1135d06b68b6f60543e67343b117227 100644 (file)
--- a/refs.h
+++ b/refs.h
@@ -163,7 +163,15 @@ extern void rollback_packed_refs(void);
  */
 int pack_refs(unsigned int flags);
 
  */
 int pack_refs(unsigned int flags);
 

-extern int repack_without_refs(const char **refnames, int n,
+/*
+ * Rewrite the packed-refs file, omitting any refs listed in
+ * 'refnames'. On error, packed-refs will be unchanged, the return
+ * value is nonzero, and a message about the error is written to the
+ * 'err' strbuf.
+ *
+ * The refs in 'refnames' needn't be sorted. `err` must not be NULL.
+ */
+extern int repack_without_refs(struct string_list *refnames,

                               struct strbuf *err);
 
 extern int ref_exists(const char *);
                               struct strbuf *err);
 
 extern int ref_exists(const char *);