reftable/basics: stop using `SWAP()` macro

Stop using `SWAP()` macro in favor of an open-coded variant of it. Note
that this also requires us to open-code the build assert that `SWAP()`
itself uses to verify that the size of both variables matches.

This is done to reduce our dependency on the Git codebase.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/reftable/basics.h b/reftable/basics.h
index c1ddbaec3ff581bdfd2569efb51954c551705cc0..59000798f0be1f4e0fbc56d5a93eafa1b5f6c804 100644 (file)
--- a/reftable/basics.h
+++ b/reftable/basics.h
@@ -266,6 +266,15 @@ static inline void *reftable_alloc_grow(void *p, size_t nelem, size_t elsize,
 # define strdup(str) REFTABLE_BANNED(strdup)
 #endif
 
+#define REFTABLE_SWAP(a, b) do {                                                               \
+       void *_swap_a_ptr = &(a);                                                               \
+       void *_swap_b_ptr = &(b);                                                               \
+       unsigned char _swap_buffer[sizeof(a) - 2 * sizeof(a) * (sizeof(a) != sizeof(b))];       \
+       memcpy(_swap_buffer, _swap_a_ptr, sizeof(a));                                           \
+       memcpy(_swap_a_ptr, _swap_b_ptr, sizeof(a));                                            \
+       memcpy(_swap_b_ptr, _swap_buffer, sizeof(a));                                           \
+} while (0)
+
 /* Find the longest shared prefix size of `a` and `b` */
 size_t common_prefix_size(struct reftable_buf *a, struct reftable_buf *b);
 

diff --git a/reftable/merged.c b/reftable/merged.c
index 563864068c1882779261597bf4528fe338e690c7..4ff1553772a037a7d06e88d075f4b90c59e2f6ae 100644 (file)
--- a/reftable/merged.c
+++ b/reftable/merged.c
@@ -155,7 +155,7 @@ static int merged_iter_next_entry(struct merged_iter *mi,
        }
 
        mi->advance_index = entry.index;
-       SWAP(*rec, *entry.rec);
+       REFTABLE_SWAP(*rec, *entry.rec);
        return 0;
 }
 

diff --git a/reftable/pq.c b/reftable/pq.c
index ef8035cfd9b6925caaebb5033074cb38e5a42d77..82394a972db2d993415b04b24182ff8ddfdcc2df 100644 (file)
--- a/reftable/pq.c
+++ b/reftable/pq.c
@@ -57,7 +57,7 @@ int merged_iter_pqueue_remove(struct merged_iter_pqueue *pq, struct pq_entry *ou
 
                if (min == i)
                        break;
-               SWAP(pq->heap[i], pq->heap[min]);
+               REFTABLE_SWAP(pq->heap[i], pq->heap[min]);
                i = min;
        }
 
@@ -81,7 +81,7 @@ int merged_iter_pqueue_add(struct merged_iter_pqueue *pq, const struct pq_entry
                size_t j = (i - 1) / 2;
                if (pq_less(&pq->heap[j], &pq->heap[i]))
                        break;
-               SWAP(pq->heap[j], pq->heap[i]);
+               REFTABLE_SWAP(pq->heap[j], pq->heap[i]);
                i = j;
        }
 

diff --git a/reftable/record.c b/reftable/record.c
index 3552bafa9945ebce90e34f6d94f69867f47e9227..9a1edf39a0279b6d5c15b5ce2bf0d52a47146fee 100644 (file)
--- a/reftable/record.c
+++ b/reftable/record.c
@@ -237,11 +237,11 @@ static int reftable_ref_record_copy_from(void *rec, const void *src_rec,
        size_t refname_cap = 0;
        int err;
 
-       SWAP(refname, ref->refname);
-       SWAP(refname_cap, ref->refname_cap);
+       REFTABLE_SWAP(refname, ref->refname);
+       REFTABLE_SWAP(refname_cap, ref->refname_cap);
        reftable_ref_record_release(ref);
-       SWAP(ref->refname, refname);
-       SWAP(ref->refname_cap, refname_cap);
+       REFTABLE_SWAP(ref->refname, refname);
+       REFTABLE_SWAP(ref->refname_cap, refname_cap);
 
        if (src->refname) {
                size_t refname_len = strlen(src->refname);
@@ -376,11 +376,11 @@ static int reftable_ref_record_decode(void *rec, struct reftable_buf key,
                return n;
        string_view_consume(&in, n);
 
-       SWAP(refname, r->refname);
-       SWAP(refname_cap, r->refname_cap);
+       REFTABLE_SWAP(refname, r->refname);
+       REFTABLE_SWAP(refname_cap, r->refname_cap);
        reftable_ref_record_release(r);
-       SWAP(r->refname, refname);
-       SWAP(r->refname_cap, refname_cap);
+       REFTABLE_SWAP(r->refname, refname);
+       REFTABLE_SWAP(r->refname_cap, refname_cap);
 
        REFTABLE_ALLOC_GROW_OR_NULL(r->refname, key.len + 1, r->refname_cap);
        if (!r->refname) {