reftable/record: stop using `BUG()` in `reftable_record_init()`

We're aborting the program via `BUG()` in case `reftable_record_init()`
was invoked with an unknown record type. This is bad because we may now
die in library code, and because it makes us depend on the Git codebase.

Refactor the code such that `reftable_record_init()` can return an error
code to the caller. Adapt any callers accordingly.

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

diff --git a/reftable/block.c b/reftable/block.c
index b14a8f1259aef11d299e07b5962d4fdf1c675f42..999876826d1fd77f8df265409335c24bb9d20175 100644 (file)
--- a/reftable/block.c
+++ b/reftable/block.c
@@ -508,7 +508,9 @@ int block_iter_seek_key(struct block_iter *it, const struct block_reader *br,
        it->block_len = br->block_len;
        it->hash_size = br->hash_size;
 
-       reftable_record_init(&rec, block_reader_type(br));
+       err = reftable_record_init(&rec, block_reader_type(br));
+       if (err < 0)
+               goto done;
 
        /*
         * We're looking for the last entry less than the wanted key so that

diff --git a/reftable/merged.c b/reftable/merged.c
index e72b39e178d4dec6ddfca970b5af71b71431397a..4156eec07fc904ffac76db1433985dd0fc348507 100644 (file)
--- a/reftable/merged.c
+++ b/reftable/merged.c
@@ -253,7 +253,10 @@ int merged_table_init_iter(struct reftable_merged_table *mt,
        }
 
        for (size_t i = 0; i < mt->readers_len; i++) {
-               reftable_record_init(&subiters[i].rec, typ);
+               ret = reftable_record_init(&subiters[i].rec, typ);
+               if (ret < 0)
+                       goto out;
+
                ret = reader_init_iter(mt->readers[i], &subiters[i].iter, typ);
                if (ret < 0)
                        goto out;

diff --git a/reftable/reader.c b/reftable/reader.c
index 3f2e4b280055ff58178c5b09d7822f47baa5faa1..de6e6dd93220a7591b6d6e09cb9680547673d20c 100644 (file)
--- a/reftable/reader.c
+++ b/reftable/reader.c
@@ -360,7 +360,10 @@ static int table_iter_seek_linear(struct table_iter *ti,
        struct reftable_record rec;
        int err;
 
-       reftable_record_init(&rec, reftable_record_type(want));
+       err = reftable_record_init(&rec, reftable_record_type(want));
+       if (err < 0)
+               goto done;
+
        err = reftable_record_key(want, &want_key);
        if (err < 0)
                goto done;

diff --git a/reftable/record.c b/reftable/record.c
index 2c0cc32cbd35f8418c0993b649352b3d49bd7337..1e18f8dffb1300a86a5854933d2c600b5a491c33 100644 (file)
--- a/reftable/record.c
+++ b/reftable/record.c
@@ -1306,7 +1306,7 @@ reftable_record_vtable(struct reftable_record *rec)
        abort();
 }
 
-void reftable_record_init(struct reftable_record *rec, uint8_t typ)
+int reftable_record_init(struct reftable_record *rec, uint8_t typ)
 {
        memset(rec, 0, sizeof(*rec));
        rec->type = typ;
@@ -1315,11 +1315,11 @@ void reftable_record_init(struct reftable_record *rec, uint8_t typ)
        case BLOCK_TYPE_REF:
        case BLOCK_TYPE_LOG:
        case BLOCK_TYPE_OBJ:
-               return;
+               return 0;
        case BLOCK_TYPE_INDEX:
                reftable_buf_init(&rec->u.idx.last_key);
-               return;
+               return 0;
        default:
-               BUG("unhandled record type");
+               return REFTABLE_API_ERROR;
        }
 }

diff --git a/reftable/record.h b/reftable/record.h
index c7755a4d750339accf670c0a976c490a45d1ff14..e1846c294ba0bae1ce65054449d93c15f68e74f5 100644 (file)
--- a/reftable/record.h
+++ b/reftable/record.h
@@ -130,8 +130,8 @@ struct reftable_record {
        } u;
 };
 
-/* Initialize the reftable record for the given type */
-void reftable_record_init(struct reftable_record *rec, uint8_t typ);
+/* Initialize the reftable record for the given type. */
+int reftable_record_init(struct reftable_record *rec, uint8_t typ);
 
 /* see struct record_vtable */
 int reftable_record_cmp(struct reftable_record *a, struct reftable_record *b);

diff --git a/t/unit-tests/t-reftable-pq.c b/t/unit-tests/t-reftable-pq.c
index f3f8a0cdf385795aae33567df86d08e6dcbbda5b..d8a4c283a11701111fa01853d4d4ec60cd8c958b 100644 (file)
--- a/t/unit-tests/t-reftable-pq.c
+++ b/t/unit-tests/t-reftable-pq.c
@@ -32,7 +32,7 @@ static void t_pq_record(void)
        char *last = NULL;
 
        for (i = 0; i < N; i++) {
-               reftable_record_init(&recs[i], BLOCK_TYPE_REF);
+               check(!reftable_record_init(&recs[i], BLOCK_TYPE_REF));
                recs[i].u.ref.refname = xstrfmt("%02"PRIuMAX, (uintmax_t)i);
        }
 
@@ -72,7 +72,7 @@ static void t_pq_index(void)
        size_t N = ARRAY_SIZE(recs), i;
 
        for (i = 0; i < N; i++) {
-               reftable_record_init(&recs[i], BLOCK_TYPE_REF);
+               check(!reftable_record_init(&recs[i], BLOCK_TYPE_REF));
                recs[i].u.ref.refname = (char *) "refs/heads/master";
        }
 
@@ -111,7 +111,7 @@ static void t_merged_iter_pqueue_top(void)
        size_t N = ARRAY_SIZE(recs), i;
 
        for (i = 0; i < N; i++) {
-               reftable_record_init(&recs[i], BLOCK_TYPE_REF);
+               check(!reftable_record_init(&recs[i], BLOCK_TYPE_REF));
                recs[i].u.ref.refname = (char *) "refs/heads/master";
        }
 

diff --git a/t/unit-tests/t-reftable-record.c b/t/unit-tests/t-reftable-record.c
index d49d2a2729cb1769601367961d0759dc928172d1..6540bd20e37f1437b19cfc902cf65d1d0042b196 100644 (file)
--- a/t/unit-tests/t-reftable-record.c
+++ b/t/unit-tests/t-reftable-record.c
@@ -17,7 +17,7 @@ static void t_copy(struct reftable_record *rec)
        uint8_t typ;
 
        typ = reftable_record_type(rec);
-       reftable_record_init(&copy, typ);
+       check(!reftable_record_init(&copy, typ));
        reftable_record_copy_from(&copy, rec, REFTABLE_HASH_SIZE_SHA1);
        /* do it twice to catch memory leaks */
        reftable_record_copy_from(&copy, rec, REFTABLE_HASH_SIZE_SHA1);