From: "Han-Wen Nienhuys via GitGitGadget" <gitgitgadget@gmail.com>
To: git@vger.kernel.org
Cc: Han-Wen Nienhuys <hanwen@google.com>, Jeff King <peff@peff.net>,
Han-Wen Nienhuys <hanwenn@gmail.com>
Subject: [PATCH v2 00/13] reftable library
Date: Thu, 01 Oct 2020 16:10:50 +0000 [thread overview]
Message-ID: <pull.847.v2.git.git.1601568663.gitgitgadget@gmail.com> (raw)
In-Reply-To: <pull.847.git.git.1600283416.gitgitgadget@gmail.com>
This splits the giant commit from
https://github.com/gitgitgadget/git/pull/539 into a series of smaller
commits, which build and have unittests.
The final commit should also be split up, but I want to wait until we have
consensus that the bottom commits look good.
Han-Wen Nienhuys (12):
reftable: add LICENSE
reftable: define the public API
reftable: add a barebones unittest framework
reftable: utility functions
reftable: (de)serialization for the polymorphic record type.
reftable: reading/writing blocks
reftable: a generic binary tree implementation
reftable: write reftable files
reftable: read reftable files
reftable: file level tests
reftable: rest of library
reftable: "test-tool dump-reftable" command.
Johannes Schindelin (1):
vcxproj: adjust for the reftable changes
Makefile | 46 +-
config.mak.uname | 2 +-
contrib/buildsystems/Generators/Vcxproj.pm | 11 +-
reftable/.gitattributes | 1 +
reftable/LICENSE | 31 +
reftable/VERSION | 1 +
reftable/basics.c | 131 +++
reftable/basics.h | 48 +
reftable/block.c | 441 +++++++
reftable/block.h | 129 ++
reftable/block_test.c | 158 +++
reftable/blocksource.c | 148 +++
reftable/blocksource.h | 22 +
reftable/compat.c | 110 ++
reftable/compat.h | 48 +
reftable/constants.h | 21 +
reftable/dump.c | 212 ++++
reftable/iter.c | 242 ++++
reftable/iter.h | 72 ++
reftable/merged.c | 358 ++++++
reftable/merged.h | 36 +
reftable/merged_test.c | 331 ++++++
reftable/pq.c | 115 ++
reftable/pq.h | 32 +
reftable/publicbasics.c | 100 ++
reftable/reader.c | 733 ++++++++++++
reftable/reader.h | 78 ++
reftable/record.c | 1116 ++++++++++++++++++
reftable/record.h | 137 +++
reftable/record_test.c | 410 +++++++
reftable/refname.c | 209 ++++
reftable/refname.h | 28 +
reftable/refname_test.c | 100 ++
reftable/reftable-tests.h | 22 +
reftable/reftable.c | 104 ++
reftable/reftable.h | 585 +++++++++
reftable/reftable_test.c | 585 +++++++++
reftable/stack.c | 1240 ++++++++++++++++++++
reftable/stack.h | 40 +
reftable/stack_test.c | 788 +++++++++++++
reftable/strbuf.c | 142 +++
reftable/strbuf.h | 80 ++
reftable/strbuf_test.c | 37 +
reftable/system.h | 51 +
reftable/test_framework.c | 68 ++
reftable/test_framework.h | 59 +
reftable/tree.c | 63 +
reftable/tree.h | 34 +
reftable/tree_test.c | 62 +
reftable/update.sh | 22 +
reftable/writer.c | 673 +++++++++++
reftable/writer.h | 51 +
reftable/zlib-compat.c | 92 ++
t/helper/test-reftable.c | 20 +
t/helper/test-tool.c | 2 +
t/helper/test-tool.h | 2 +
56 files changed, 10474 insertions(+), 5 deletions(-)
create mode 100644 reftable/.gitattributes
create mode 100644 reftable/LICENSE
create mode 100644 reftable/VERSION
create mode 100644 reftable/basics.c
create mode 100644 reftable/basics.h
create mode 100644 reftable/block.c
create mode 100644 reftable/block.h
create mode 100644 reftable/block_test.c
create mode 100644 reftable/blocksource.c
create mode 100644 reftable/blocksource.h
create mode 100644 reftable/compat.c
create mode 100644 reftable/compat.h
create mode 100644 reftable/constants.h
create mode 100644 reftable/dump.c
create mode 100644 reftable/iter.c
create mode 100644 reftable/iter.h
create mode 100644 reftable/merged.c
create mode 100644 reftable/merged.h
create mode 100644 reftable/merged_test.c
create mode 100644 reftable/pq.c
create mode 100644 reftable/pq.h
create mode 100644 reftable/publicbasics.c
create mode 100644 reftable/reader.c
create mode 100644 reftable/reader.h
create mode 100644 reftable/record.c
create mode 100644 reftable/record.h
create mode 100644 reftable/record_test.c
create mode 100644 reftable/refname.c
create mode 100644 reftable/refname.h
create mode 100644 reftable/refname_test.c
create mode 100644 reftable/reftable-tests.h
create mode 100644 reftable/reftable.c
create mode 100644 reftable/reftable.h
create mode 100644 reftable/reftable_test.c
create mode 100644 reftable/stack.c
create mode 100644 reftable/stack.h
create mode 100644 reftable/stack_test.c
create mode 100644 reftable/strbuf.c
create mode 100644 reftable/strbuf.h
create mode 100644 reftable/strbuf_test.c
create mode 100644 reftable/system.h
create mode 100644 reftable/test_framework.c
create mode 100644 reftable/test_framework.h
create mode 100644 reftable/tree.c
create mode 100644 reftable/tree.h
create mode 100644 reftable/tree_test.c
create mode 100755 reftable/update.sh
create mode 100644 reftable/writer.c
create mode 100644 reftable/writer.h
create mode 100644 reftable/zlib-compat.c
create mode 100644 t/helper/test-reftable.c
base-commit: 306ee63a703ad67c54ba1209dc11dd9ea500dc1f
Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-847%2Fhanwen%2Flibreftable-v2
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-847/hanwen/libreftable-v2
Pull-Request: https://github.com/git/git/pull/847
Range-diff vs v1:
1: f697eac228 = 1: 6228103b4a reftable: add LICENSE
2: e2dbc84833 = 2: 5d1b946ab5 reftable: define the public API
3: 0f6efc065c = 3: 01a669a731 vcxproj: adjust for the reftable changes
4: 7bf59d491d ! 4: b94c5f5c61 reftable: add a barebones unittest framework
@@ reftable/test_framework.c (new)
+#include "system.h"
+#include "basics.h"
+
-+struct test_case **test_cases;
-+int test_case_len;
-+int test_case_cap;
++static struct test_case **test_cases;
++static int test_case_len;
++static int test_case_cap;
+
-+struct test_case *new_test_case(const char *name, void (*testfunc)(void))
++static struct test_case *new_test_case(const char *name, void (*testfunc)(void))
+{
+ struct test_case *tc = reftable_malloc(sizeof(struct test_case));
+ tc->name = name;
@@ reftable/test_framework.c (new)
+ reftable_free(test_cases[i]);
+ }
+ reftable_free(test_cases);
-+ test_cases = 0;
++ test_cases = NULL;
+ test_case_len = 0;
+ test_case_cap = 0;
+ return 0;
@@ reftable/test_framework.h (new)
+ void (*testfunc)(void);
+};
+
-+struct test_case *new_test_case(const char *name, void (*testfunc)(void));
+struct test_case *add_test_case(const char *name, void (*testfunc)(void));
+int test_main(int argc, const char *argv[]);
+
5: 570a8c4bca ! 5: 4190da597e reftable: utility functions
@@ reftable/blocksource.c (new)
+ return ((struct strbuf *)b)->len;
+}
+
-+struct reftable_block_source_vtable strbuf_vtable = {
++static struct reftable_block_source_vtable strbuf_vtable = {
+ .size = &strbuf_size,
+ .read_block = &strbuf_read_block,
+ .return_block = &strbuf_return_block,
@@ reftable/blocksource.c (new)
+ reftable_free(dest->data);
+}
+
-+struct reftable_block_source_vtable malloc_vtable = {
++static struct reftable_block_source_vtable malloc_vtable = {
+ .return_block = &malloc_return_block,
+};
+
-+struct reftable_block_source malloc_block_source_instance = {
++static struct reftable_block_source malloc_block_source_instance = {
+ .ops = &malloc_vtable,
+};
+
@@ reftable/blocksource.c (new)
+ return size;
+}
+
-+struct reftable_block_source_vtable file_vtable = {
++static struct reftable_block_source_vtable file_vtable = {
+ .size = &file_size,
+ .read_block = &file_read_block,
+ .return_block = &file_return_block,
@@ reftable/publicbasics.c (new)
+ }
+}
+
-+void *(*reftable_malloc_ptr)(size_t sz) = &malloc;
-+void *(*reftable_realloc_ptr)(void *, size_t) = &realloc;
-+void (*reftable_free_ptr)(void *) = &free;
++static void *(*reftable_malloc_ptr)(size_t sz) = &malloc;
++static void *(*reftable_realloc_ptr)(void *, size_t) = &realloc;
++static void (*reftable_free_ptr)(void *) = &free;
+
+void *reftable_malloc(size_t sz)
+{
6: 791f69c000 ! 6: 8eb944ea9b reftable: (de)serialization for the polymorphic record type.
@@ reftable/record.c (new)
+ (const struct reftable_ref_record *)p);
+}
+
-+struct reftable_record_vtable reftable_ref_record_vtable = {
++static struct reftable_record_vtable reftable_ref_record_vtable = {
+ .key = &reftable_ref_record_key,
+ .type = BLOCK_TYPE_REF,
+ .copy_from = &reftable_ref_record_copy_from,
@@ reftable/record.c (new)
+ return 0;
+}
+
-+struct reftable_record_vtable reftable_obj_record_vtable = {
++static struct reftable_record_vtable reftable_obj_record_vtable = {
+ .key = &reftable_obj_record_key,
+ .type = BLOCK_TYPE_OBJ,
+ .copy_from = &reftable_obj_record_copy_from,
@@ reftable/record.c (new)
+ (const struct reftable_log_record *)p);
+}
+
-+struct reftable_record_vtable reftable_log_record_vtable = {
++static struct reftable_record_vtable reftable_log_record_vtable = {
+ .key = &reftable_log_record_key,
+ .type = BLOCK_TYPE_LOG,
+ .copy_from = &reftable_log_record_copy_from,
@@ reftable/record.c (new)
+ return rec;
+}
+
-+void *reftable_record_yield(struct reftable_record *rec)
++/* clear out the record, yielding the reftable_record data that was
++ * encapsulated. */
++static void *reftable_record_yield(struct reftable_record *rec)
+{
+ void *p = rec->data;
+ rec->data = NULL;
@@ reftable/record.c (new)
+ return start.len - in.len;
+}
+
-+struct reftable_record_vtable reftable_index_record_vtable = {
++static struct reftable_record_vtable reftable_index_record_vtable = {
+ .key = &reftable_index_record_key,
+ .type = BLOCK_TYPE_INDEX,
+ .copy_from = &reftable_index_record_copy_from,
@@ reftable/record.h (new)
+/* creates a malloced record of the given type. Dispose with record_destroy */
+struct reftable_record reftable_new_record(uint8_t typ);
+
-+extern struct reftable_record_vtable reftable_ref_record_vtable;
-+
+/* Encode `key` into `dest`. Sets `is_restart` to indicate a restart. Returns
+ number of bytes written. */
+int reftable_encode_key(int *is_restart, struct string_view dest,
@@ reftable/record.h (new)
+/* zeroes out the embedded record */
+void reftable_record_clear(struct reftable_record *rec);
+
-+/* clear out the record, yielding the reftable_record data that was
-+ * encapsulated. */
-+void *reftable_record_yield(struct reftable_record *rec);
-+
+/* clear and deallocate embedded record, and zero `rec`. */
+void reftable_record_destroy(struct reftable_record *rec);
+
@@ reftable/record_test.c (new)
+ int i = 0;
+
+ for (i = 0; i <= 3; i++) {
-+ struct reftable_ref_record in = { 0 };
++ struct reftable_ref_record in = { NULL };
+ struct reftable_ref_record out = {
+ .refname = xstrdup("old name"),
+ .value = reftable_calloc(SHA1_SIZE),
+ .target_value = reftable_calloc(SHA1_SIZE),
+ .target = xstrdup("old value"),
+ };
-+ struct reftable_record rec_out = { 0 };
++ struct reftable_record rec_out = { NULL };
+ struct strbuf key = STRBUF_INIT;
-+ struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ uint8_t buffer[1024] = { 0 };
+ struct string_view dest = {
+ .buf = buffer,
@@ reftable/record_test.c (new)
+ set_test_hash(in[0].new_hash, 1);
+ set_test_hash(in[0].old_hash, 2);
+ for (int i = 0; i < ARRAY_SIZE(in); i++) {
-+ struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ struct strbuf key = STRBUF_INIT;
+ uint8_t buffer[1024] = { 0 };
+ struct string_view dest = {
@@ reftable/record_test.c (new)
+ .email = xstrdup("old@email"),
+ .message = xstrdup("old message"),
+ };
-+ struct reftable_record rec_out = { 0 };
++ struct reftable_record rec_out = { NULL };
+ int n, m, valtype;
+
+ reftable_record_from_log(&rec, &in[i]);
@@ reftable/record_test.c (new)
+ .buf = buffer,
+ .len = sizeof(buffer),
+ };
-+ struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ struct strbuf key = STRBUF_INIT;
-+ struct reftable_obj_record out = { 0 };
-+ struct reftable_record rec_out = { 0 };
++ struct reftable_obj_record out = { NULL };
++ struct reftable_record rec_out = { NULL };
+ int n, m;
+ uint8_t extra;
+
@@ reftable/record_test.c (new)
+ .len = sizeof(buffer),
+ };
+ struct strbuf key = STRBUF_INIT;
-+ struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ struct reftable_index_record out = { .last_key = STRBUF_INIT };
+ struct reftable_record out_rec = { NULL };
+ int n, m;
7: 1ba8e3eb30 ! 7: 757dd30fe2 reftable: reading/writing blocks
@@ reftable/block.c (new)
+ abort();
+}
+
-+int block_writer_register_restart(struct block_writer *w, int n, int restart,
-+ struct strbuf *key);
++static int block_writer_register_restart(struct block_writer *w, int n,
++ int is_restart, struct strbuf *key)
++{
++ int rlen = w->restart_len;
++ if (rlen >= MAX_RESTARTS) {
++ is_restart = 0;
++ }
++
++ if (is_restart) {
++ rlen++;
++ }
++ if (2 + 3 * rlen + n > w->block_size - w->next)
++ return -1;
++ if (is_restart) {
++ if (w->restart_len == w->restart_cap) {
++ w->restart_cap = w->restart_cap * 2 + 1;
++ w->restarts = reftable_realloc(
++ w->restarts, sizeof(uint32_t) * w->restart_cap);
++ }
++
++ w->restarts[w->restart_len++] = w->next;
++ }
++
++ w->next += n;
++
++ strbuf_reset(&w->last_key);
++ strbuf_addbuf(&w->last_key, key);
++ w->entries++;
++ return 0;
++}
+
+void block_writer_init(struct block_writer *bw, uint8_t typ, uint8_t *buf,
+ uint32_t block_size, uint32_t header_off, int hash_size)
@@ reftable/block.c (new)
+ return -1;
+}
+
-+int block_writer_register_restart(struct block_writer *w, int n, int is_restart,
-+ struct strbuf *key)
-+{
-+ int rlen = w->restart_len;
-+ if (rlen >= MAX_RESTARTS) {
-+ is_restart = 0;
-+ }
-+
-+ if (is_restart) {
-+ rlen++;
-+ }
-+ if (2 + 3 * rlen + n > w->block_size - w->next)
-+ return -1;
-+ if (is_restart) {
-+ if (w->restart_len == w->restart_cap) {
-+ w->restart_cap = w->restart_cap * 2 + 1;
-+ w->restarts = reftable_realloc(
-+ w->restarts, sizeof(uint32_t) * w->restart_cap);
-+ }
-+
-+ w->restarts[w->restart_len++] = w->next;
-+ }
-+
-+ w->next += n;
-+
-+ strbuf_reset(&w->last_key);
-+ strbuf_addbuf(&w->last_key, key);
-+ w->entries++;
-+ return 0;
-+}
+
+int block_writer_finish(struct block_writer *w)
+{
@@ reftable/block_test.c (new)
+ char *names[30];
+ const int N = ARRAY_SIZE(names);
+ const int block_size = 1024;
-+ struct reftable_block block = { 0 };
++ struct reftable_block block = { NULL };
+ struct block_writer bw = {
+ .last_key = STRBUF_INIT,
+ };
-+ struct reftable_ref_record ref = { 0 };
-+ struct reftable_record rec = { 0 };
++ struct reftable_ref_record ref = { NULL };
++ struct reftable_record rec = { NULL };
+ int i = 0;
+ int n;
+ struct block_reader br = { 0 };
8: 17fb8d050d ! 8: e30a7e0281 reftable: a generic binary tree implementation
@@ reftable/tree_test.c (new)
+{
+ struct tree_node *root = NULL;
+
-+ void *values[11] = { 0 };
-+ struct tree_node *nodes[11] = { 0 };
++ void *values[11] = { NULL };
++ struct tree_node *nodes[11] = { NULL };
+ int i = 1;
-+ struct curry c = { 0 };
++ struct curry c = { NULL };
+ do {
+ nodes[i] = tree_search(values + i, &root, &test_compare, 1);
+ i = (i * 7) % 11;
9: 4e40fc3b40 ! 9: 68aee16e60 reftable: write reftable files
@@ reftable/writer.c (new)
+#include "reftable.h"
+#include "tree.h"
+
++/* finishes a block, and writes it to storage */
++static int writer_flush_block(struct reftable_writer *w);
++
++/* deallocates memory related to the index */
++static void writer_clear_index(struct reftable_writer *w);
++
++/* finishes writing a 'r' (refs) or 'g' (reflogs) section */
++static int writer_finish_public_section(struct reftable_writer *w);
++
+static struct reftable_block_stats *
+writer_reftable_block_stats(struct reftable_writer *w, uint8_t typ)
+{
@@ reftable/writer.c (new)
+int reftable_writer_add_ref(struct reftable_writer *w,
+ struct reftable_ref_record *ref)
+{
-+ struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ struct reftable_ref_record copy = *ref;
+ int err = 0;
+
@@ reftable/writer.c (new)
+int reftable_writer_add_log(struct reftable_writer *w,
+ struct reftable_log_record *log)
+{
-+ struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ char *input_log_message = log->message;
+ struct strbuf cleaned_message = STRBUF_INIT;
+ int err;
@@ reftable/writer.c (new)
+ w->index_len = 0;
+ w->index_cap = 0;
+ for (i = 0; i < idx_len; i++) {
-+ struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ reftable_record_from_index(&rec, idx + i);
+ if (block_writer_add(w->block_writer, &rec) == 0) {
+ continue;
@@ reftable/writer.c (new)
+ .offsets = entry->offsets,
+ .offset_len = entry->offset_len,
+ };
-+ struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ if (arg->err < 0)
+ goto done;
+
@@ reftable/writer.c (new)
+static int writer_dump_object_index(struct reftable_writer *w)
+{
+ struct write_record_arg closure = { .w = w };
-+ struct common_prefix_arg common = { 0 };
++ struct common_prefix_arg common = { NULL };
+ if (w->obj_index_tree != NULL) {
+ infix_walk(w->obj_index_tree, &update_common, &common);
+ }
@@ reftable/writer.c (new)
+ return writer_finish_section(w);
+}
+
-+int writer_finish_public_section(struct reftable_writer *w)
++static int writer_finish_public_section(struct reftable_writer *w)
+{
+ uint8_t typ = 0;
+ int err = 0;
@@ reftable/writer.c (new)
+ return err;
+}
+
-+void writer_clear_index(struct reftable_writer *w)
++static void writer_clear_index(struct reftable_writer *w)
+{
+ int i = 0;
+ for (i = 0; i < w->index_len; i++) {
@@ reftable/writer.c (new)
+ w->index_cap = 0;
+}
+
-+const int debug = 0;
++static const int debug = 0;
+
+static int writer_flush_nonempty_block(struct reftable_writer *w)
+{
@@ reftable/writer.c (new)
+ return 0;
+}
+
-+int writer_flush_block(struct reftable_writer *w)
++static int writer_flush_block(struct reftable_writer *w)
+{
+ if (w->block_writer == NULL)
+ return 0;
@@ reftable/writer.h (new)
+ struct reftable_stats stats;
+};
+
-+/* finishes a block, and writes it to storage */
-+int writer_flush_block(struct reftable_writer *w);
-+
-+/* deallocates memory related to the index */
-+void writer_clear_index(struct reftable_writer *w);
-+
-+/* finishes writing a 'r' (refs) or 'g' (reflogs) section */
-+int writer_finish_public_section(struct reftable_writer *w);
-+
+#endif
10: 25259b683b ! 10: c196de7f06 reftable: read reftable files
@@ reftable/iter.c (new)
+{
+}
+
-+struct reftable_iterator_vtable empty_vtable = {
++static struct reftable_iterator_vtable empty_vtable = {
+ .next = &empty_iterator_next,
+ .close = &empty_iterator_close,
+};
@@ reftable/iter.c (new)
+ return err;
+}
+
-+struct reftable_iterator_vtable filtering_ref_iterator_vtable = {
++static struct reftable_iterator_vtable filtering_ref_iterator_vtable = {
+ .next = &filtering_ref_iterator_next,
+ .close = &filtering_ref_iterator_close,
+};
@@ reftable/iter.c (new)
+ return err;
+}
+
-+struct reftable_iterator_vtable indexed_table_ref_iter_vtable = {
++static struct reftable_iterator_vtable indexed_table_ref_iter_vtable = {
+ .next = &indexed_table_ref_iter_next,
+ .close = &indexed_table_ref_iter_close,
+};
@@ reftable/reader.c (new)
+ block_iter_close(&ti->bi);
+}
+
-+struct reftable_iterator_vtable table_iter_vtable = {
++static struct reftable_iterator_vtable table_iter_vtable = {
+ .next = &table_iter_next_void,
+ .close = &table_iter_close,
+};
11: 3448fcf828 ! 11: bf6b929b86 reftable: file level tests
@@ reftable/reftable_test.c (new)
+{
+ struct strbuf buf = STRBUF_INIT;
+ struct reftable_block_source source = { NULL };
-+ struct reftable_block out = { 0 };
++ struct reftable_block out = { NULL };
+ int n;
+ uint8_t in[] = "hello";
+ strbuf_add(&buf, in, sizeof(in));
@@ reftable/reftable_test.c (new)
+ };
+ struct reftable_writer *w =
+ reftable_new_writer(&strbuf_add_void, buf, &opts);
-+ struct reftable_ref_record ref = { 0 };
++ struct reftable_ref_record ref = { NULL };
+ int i = 0, n;
-+ struct reftable_log_record log = { 0 };
++ struct reftable_log_record log = { NULL };
+ const struct reftable_stats *stats = NULL;
+ *names = reftable_calloc(sizeof(char *) * (N + 1));
+ reftable_writer_set_limits(w, update_index, update_index);
@@ reftable/reftable_test.c (new)
+ struct reftable_write_options opts = {
+ .block_size = 256,
+ };
-+ struct reftable_ref_record ref = { 0 };
++ struct reftable_ref_record ref = { NULL };
+ int i = 0;
-+ struct reftable_log_record log = { 0 };
++ struct reftable_log_record log = { NULL };
+ int n;
-+ struct reftable_iterator it = { 0 };
-+ struct reftable_reader rd = { 0 };
-+ struct reftable_block_source source = { 0 };
++ struct reftable_iterator it = { NULL };
++ struct reftable_reader rd = { NULL };
++ struct reftable_block_source source = { NULL };
+ struct strbuf buf = STRBUF_INIT;
+ struct reftable_writer *w =
+ reftable_new_writer(&strbuf_add_void, &buf, &opts);
@@ reftable/reftable_test.c (new)
+ reftable_writer_set_limits(w, 0, N);
+ for (i = 0; i < N; i++) {
+ char name[256];
-+ struct reftable_ref_record ref = { 0 };
++ struct reftable_ref_record ref = { NULL };
+ snprintf(name, sizeof(name), "b%02d%0*d", i, 130, 7);
+ names[i] = xstrdup(name);
+ ref.refname = name;
@@ reftable/reftable_test.c (new)
+ }
+ for (i = 0; i < N; i++) {
+ uint8_t hash1[SHA1_SIZE], hash2[SHA1_SIZE];
-+ struct reftable_log_record log = { 0 };
++ struct reftable_log_record log = { NULL };
+ set_test_hash(hash1, i);
+ set_test_hash(hash2, i + 1);
+
@@ reftable/reftable_test.c (new)
+ char **names;
+ struct strbuf buf = STRBUF_INIT;
+ int N = 50;
-+ struct reftable_iterator it = { 0 };
-+ struct reftable_block_source source = { 0 };
-+ struct reftable_reader rd = { 0 };
++ struct reftable_iterator it = { NULL };
++ struct reftable_block_source source = { NULL };
++ struct reftable_reader rd = { NULL };
+ int err = 0;
+ int j = 0;
+
@@ reftable/reftable_test.c (new)
+ assert_err(err);
+
+ while (1) {
-+ struct reftable_ref_record ref = { 0 };
++ struct reftable_ref_record ref = { NULL };
+ int r = reftable_iterator_next_ref(&it, &ref);
+ assert(r >= 0);
+ if (r > 0) {
@@ reftable/reftable_test.c (new)
+ char **names;
+ struct strbuf buf = STRBUF_INIT;
+ int N = 50;
-+ struct reftable_reader rd = { 0 };
-+ struct reftable_block_source source = { 0 };
++ struct reftable_reader rd = { NULL };
++ struct reftable_block_source source = { NULL };
+ int err;
+ int i;
-+ struct reftable_log_record log = { 0 };
-+ struct reftable_iterator it = { 0 };
++ struct reftable_log_record log = { NULL };
++ struct reftable_iterator it = { NULL };
+
+ write_table(&names, &buf, N, 256, SHA1_ID);
+
@@ reftable/reftable_test.c (new)
+ char **names;
+ struct strbuf buf = STRBUF_INIT;
+ int N = 50;
-+ struct reftable_reader rd = { 0 };
-+ struct reftable_block_source source = { 0 };
++ struct reftable_reader rd = { NULL };
++ struct reftable_block_source source = { NULL };
+ int err;
+ int i = 0;
+
-+ struct reftable_iterator it = { 0 };
++ struct reftable_iterator it = { NULL };
+ struct strbuf pastLast = STRBUF_INIT;
-+ struct reftable_ref_record ref = { 0 };
++ struct reftable_ref_record ref = { NULL };
+
+ write_table(&names, &buf, N, 256, hash_id);
+
@@ reftable/reftable_test.c (new)
+
+ err = reftable_reader_seek_ref(&rd, &it, pastLast.buf);
+ if (err == 0) {
-+ struct reftable_ref_record ref = { 0 };
++ struct reftable_ref_record ref = { NULL };
+ int err = reftable_iterator_next_ref(&it, &ref);
+ assert(err > 0);
+ } else {
@@ reftable/reftable_test.c (new)
+ struct reftable_write_options opts = {
+ .block_size = 256,
+ };
-+ struct reftable_ref_record ref = { 0 };
++ struct reftable_ref_record ref = { NULL };
+ int i = 0;
+ int n;
+ int err;
+ struct reftable_reader rd;
-+ struct reftable_block_source source = { 0 };
++ struct reftable_block_source source = { NULL };
+
+ struct strbuf buf = STRBUF_INIT;
+ struct reftable_writer *w =
+ reftable_new_writer(&strbuf_add_void, &buf, &opts);
+
-+ struct reftable_iterator it = { 0 };
++ struct reftable_iterator it = { NULL };
+ int j;
+
+ set_test_hash(want_hash, 4);
@@ reftable/reftable_test.c (new)
+ char name[100];
+ uint8_t hash1[SHA1_SIZE];
+ uint8_t hash2[SHA1_SIZE];
-+ struct reftable_ref_record ref = { 0 };
++ struct reftable_ref_record ref = { NULL };
+
+ memset(hash, i, sizeof(hash));
+ memset(fill, 'x', 50);
@@ reftable/reftable_test.c (new)
+ struct strbuf buf = STRBUF_INIT;
+ struct reftable_writer *w =
+ reftable_new_writer(&strbuf_add_void, &buf, &opts);
-+ struct reftable_block_source source = { 0 };
++ struct reftable_block_source source = { NULL };
+ struct reftable_reader *rd = NULL;
-+ struct reftable_ref_record rec = { 0 };
-+ struct reftable_iterator it = { 0 };
++ struct reftable_ref_record rec = { NULL };
++ struct reftable_iterator it = { NULL };
+ int err;
+
+ reftable_writer_set_limits(w, 1, 1);
12: 64d98e60b2 ! 12: 4e38db7f48 reftable: rest of library
@@ Makefile: REFTABLE_OBJS += reftable/zlib-compat.o
## reftable/VERSION (new) ##
@@
-+b8ec0f74c74cb6752eb2033ad8e755a9c19aad15 C: add missing header
++7134eb9f8171a9759800f4187f9e6dde997335e7 C: NULL iso 0 for init
## reftable/dump.c (new) ##
@@
@@ reftable/dump.c (new)
+
+static int dump_table(const char *tablename)
+{
-+ struct reftable_block_source src = { 0 };
++ struct reftable_block_source src = { NULL };
+ int err = reftable_block_source_from_file(&src, tablename);
-+ struct reftable_iterator it = { 0 };
-+ struct reftable_ref_record ref = { 0 };
-+ struct reftable_log_record log = { 0 };
++ struct reftable_iterator it = { NULL };
++ struct reftable_ref_record ref = { NULL };
++ struct reftable_log_record log = { NULL };
+ struct reftable_reader *r = NULL;
+
+ if (err < 0)
@@ reftable/dump.c (new)
+{
+ struct reftable_stack *stack = NULL;
+ struct reftable_write_options cfg = {};
-+ struct reftable_iterator it = { 0 };
-+ struct reftable_ref_record ref = { 0 };
-+ struct reftable_log_record log = { 0 };
++ struct reftable_iterator it = { NULL };
++ struct reftable_ref_record ref = { NULL };
++ struct reftable_log_record log = { NULL };
+ struct reftable_merged_table *merged = NULL;
+
+ int err = reftable_new_stack(&stack, stackdir, cfg);
@@ reftable/merged.c (new)
+ return merged_iter_next(mi, rec);
+}
+
-+struct reftable_iterator_vtable merged_iter_vtable = {
++static struct reftable_iterator_vtable merged_iter_vtable = {
+ .next = &merged_iter_next_void,
+ .close = &merged_iter_close,
+};
@@ reftable/merged.c (new)
+ return mt->min;
+}
+
-+int merged_table_seek_record(struct reftable_merged_table *mt,
-+ struct reftable_iterator *it,
-+ struct reftable_record *rec)
++static int merged_table_seek_record(struct reftable_merged_table *mt,
++ struct reftable_iterator *it,
++ struct reftable_record *rec)
+{
+ struct reftable_iterator *iters = reftable_calloc(
+ sizeof(struct reftable_iterator) * mt->stack_len);
@@ reftable/merged.c (new)
+ struct reftable_ref_record ref = {
+ .refname = (char *)name,
+ };
-+ struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ reftable_record_from_ref(&rec, &ref);
+ return merged_table_seek_record(mt, it, &rec);
+}
@@ reftable/merged.c (new)
+ .refname = (char *)name,
+ .update_index = update_index,
+ };
-+ struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ reftable_record_from_log(&rec, &log);
+ return merged_table_seek_record(mt, it, &rec);
+}
@@ reftable/merged.h (new)
+};
+
+void merged_table_clear(struct reftable_merged_table *mt);
-+int merged_table_seek_record(struct reftable_merged_table *mt,
-+ struct reftable_iterator *it,
-+ struct reftable_record *rec);
+
+#endif
@@ reftable/merged_test.c (new)
+
+static void test_pq(void)
+{
-+ char *names[54] = { 0 };
++ char *names[54] = { NULL };
+ int N = ARRAY_SIZE(names) - 1;
+
-+ struct merged_iter_pqueue pq = { 0 };
++ struct merged_iter_pqueue pq = { NULL };
+ const char *last = NULL;
+
+ int i = 0;
@@ reftable/merged_test.c (new)
+ struct reftable_merged_table *mt =
+ merged_table_from_records(refs, &bs, &readers, sizes, bufs, 2);
+ int i;
-+ struct reftable_ref_record ref = { 0 };
-+ struct reftable_iterator it = { 0 };
++ struct reftable_ref_record ref = { NULL };
++ struct reftable_iterator it = { NULL };
+ int err = reftable_merged_table_seek_ref(mt, &it, "a");
+ assert_err(err);
+
@@ reftable/merged_test.c (new)
+ struct reftable_merged_table *mt =
+ merged_table_from_records(refs, &bs, &readers, sizes, bufs, 3);
+
-+ struct reftable_iterator it = { 0 };
++ struct reftable_iterator it = { NULL };
+ int err = reftable_merged_table_seek_ref(mt, &it, "a");
+ struct reftable_ref_record *out = NULL;
+ size_t len = 0;
@@ reftable/merged_test.c (new)
+
+ assert_err(err);
+ while (len < 100) { /* cap loops/recursion. */
-+ struct reftable_ref_record ref = { 0 };
++ struct reftable_ref_record ref = { NULL };
+ int err = reftable_iterator_next_ref(&it, &ref);
+ if (err > 0) {
+ break;
@@ reftable/merged_test.c (new)
+ .update_index = 1,
+ };
+ int err;
-+ struct reftable_block_source source = { 0 };
++ struct reftable_block_source source = { NULL };
+ struct reftable_table *tab = reftable_calloc(sizeof(*tab) * 1);
+ uint32_t hash_id;
+ struct reftable_reader *rd = NULL;
@@ reftable/pq.c (new)
+#include "system.h"
+#include "basics.h"
+
-+int pq_less(struct pq_entry a, struct pq_entry b)
++static int pq_less(struct pq_entry a, struct pq_entry b)
+{
+ struct strbuf ak = STRBUF_INIT;
+ struct strbuf bk = STRBUF_INIT;
@@ reftable/pq.h (new)
+ struct reftable_record rec;
+};
+
-+int pq_less(struct pq_entry a, struct pq_entry b);
-+
+struct merged_iter_pqueue {
+ struct pq_entry *heap;
+ size_t len;
@@ reftable/refname.c (new)
+ return strcmp(f_arg->names[k], f_arg->want) >= 0;
+}
+
-+int modification_has_ref(struct modification *mod, const char *name)
++static int modification_has_ref(struct modification *mod, const char *name)
+{
-+ struct reftable_ref_record ref = { 0 };
++ struct reftable_ref_record ref = { NULL };
+ int err = 0;
+
+ if (mod->add_len > 0) {
@@ reftable/refname.c (new)
+ mod->del_len = 0;
+}
+
-+int modification_has_ref_with_prefix(struct modification *mod,
-+ const char *prefix)
++static int modification_has_ref_with_prefix(struct modification *mod,
++ const char *prefix)
+{
+ struct reftable_iterator it = { NULL };
+ struct reftable_ref_record ref = { NULL };
@@ reftable/refname.c (new)
+ return err;
+}
+
-+int validate_refname(const char *name)
++static int validate_refname(const char *name)
+{
+ while (1) {
+ char *next = strchr(name, '/');
@@ reftable/refname.h (new)
+ size_t del_len;
+};
+
-+// -1 = error, 0 = found, 1 = not found
-+int modification_has_ref(struct modification *mod, const char *name);
-+
-+// -1 = error, 0 = found, 1 = not found.
-+int modification_has_ref_with_prefix(struct modification *mod,
-+ const char *prefix);
-+
-+// 0 = OK.
-+int validate_refname(const char *name);
-+
+int validate_ref_record_addition(struct reftable_table tab,
+ struct reftable_ref_record *recs, size_t sz);
+
@@ reftable/refname_test.c (new)
+ };
+ int err;
+ int i;
-+ struct reftable_block_source source = { 0 };
++ struct reftable_block_source source = { NULL };
+ struct reftable_reader *rd = NULL;
+ struct reftable_table tab = { NULL };
+ struct testcase cases[] = {
@@ reftable/refname_test.c (new)
+ return test_main(argc, argv);
+}
+ ## reftable/reftable.c ##
+@@ reftable/reftable.c: int reftable_table_seek_ref(struct reftable_table *tab,
+ struct reftable_ref_record ref = {
+ .refname = (char *)name,
+ };
+- struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ reftable_record_from_ref(&rec, &ref);
+ return tab->ops->seek_record(tab->table_arg, it, &rec);
+ }
+@@ reftable/reftable.c: void reftable_table_from_reader(struct reftable_table *tab,
+ int reftable_table_read_ref(struct reftable_table *tab, const char *name,
+ struct reftable_ref_record *ref)
+ {
+- struct reftable_iterator it = { 0 };
++ struct reftable_iterator it = { NULL };
+ int err = reftable_table_seek_ref(tab, &it, name);
+ if (err)
+ goto done;
+
## reftable/stack.c (new) ##
@@
+/*
@@ reftable/stack.c (new)
+#include "reftable.h"
+#include "writer.h"
+
++static int stack_try_add(struct reftable_stack *st,
++ int (*write_table)(struct reftable_writer *wr,
++ void *arg),
++ void *arg);
++static int stack_write_compact(struct reftable_stack *st,
++ struct reftable_writer *wr, int first, int last,
++ struct reftable_log_expiry_config *config);
++static int stack_check_addition(struct reftable_stack *st,
++ const char *new_tab_name);
++static void reftable_addition_close(struct reftable_addition *add);
++static int reftable_stack_reload_maybe_reuse(struct reftable_stack *st,
++ int reuse_open);
++
+int reftable_new_stack(struct reftable_stack **dest, const char *dir,
+ struct reftable_write_options config)
+{
@@ reftable/stack.c (new)
+ }
+
+ if (rd == NULL) {
-+ struct reftable_block_source src = { 0 };
++ struct reftable_block_source src = { NULL };
+ struct strbuf table_path = STRBUF_INIT;
+ strbuf_addstr(&table_path, st->reftable_dir);
+ strbuf_addstr(&table_path, "/");
@@ reftable/stack.c (new)
+ return udiff;
+}
+
-+int reftable_stack_reload_maybe_reuse(struct reftable_stack *st, int reuse_open)
++static int reftable_stack_reload_maybe_reuse(struct reftable_stack *st,
++ int reuse_open)
+{
+ struct timeval deadline = { 0 };
+ int err = gettimeofday(&deadline, NULL);
@@ reftable/stack.c (new)
+ return err;
+}
+
-+void reftable_addition_close(struct reftable_addition *add)
++static void reftable_addition_close(struct reftable_addition *add)
+{
+ int i = 0;
+ struct strbuf nm = STRBUF_INIT;
@@ reftable/stack.c (new)
+ return err;
+}
+
-+int stack_try_add(struct reftable_stack *st,
-+ int (*write_table)(struct reftable_writer *wr, void *arg),
-+ void *arg)
++static int stack_try_add(struct reftable_stack *st,
++ int (*write_table)(struct reftable_writer *wr,
++ void *arg),
++ void *arg)
+{
+ struct reftable_addition add = REFTABLE_ADDITION_INIT;
+ int err = reftable_stack_init_addition(&add, st);
@@ reftable/stack.c (new)
+ return err;
+}
+
-+int stack_write_compact(struct reftable_stack *st, struct reftable_writer *wr,
-+ int first, int last,
-+ struct reftable_log_expiry_config *config)
++static int stack_write_compact(struct reftable_stack *st,
++ struct reftable_writer *wr, int first, int last,
++ struct reftable_log_expiry_config *config)
+{
+ int subtabs_len = last - first + 1;
+ struct reftable_table *subtabs = reftable_calloc(
+ sizeof(struct reftable_table) * (last - first + 1));
+ struct reftable_merged_table *mt = NULL;
+ int err = 0;
-+ struct reftable_iterator it = { 0 };
-+ struct reftable_ref_record ref = { 0 };
-+ struct reftable_log_record log = { 0 };
++ struct reftable_iterator it = { NULL };
++ struct reftable_ref_record ref = { NULL };
++ struct reftable_log_record log = { NULL };
+
+ uint64_t entries = 0;
+
@@ reftable/stack.c (new)
+int reftable_stack_read_log(struct reftable_stack *st, const char *refname,
+ struct reftable_log_record *log)
+{
-+ struct reftable_iterator it = { 0 };
++ struct reftable_iterator it = { NULL };
+ struct reftable_merged_table *mt = reftable_stack_merged_table(st);
+ int err = reftable_merged_table_seek_log(mt, &it, refname);
+ if (err)
@@ reftable/stack.c (new)
+ return err;
+}
+
-+int stack_check_addition(struct reftable_stack *st, const char *new_tab_name)
++static int stack_check_addition(struct reftable_stack *st,
++ const char *new_tab_name)
+{
+ int err = 0;
-+ struct reftable_block_source src = { 0 };
++ struct reftable_block_source src = { NULL };
+ struct reftable_reader *rd = NULL;
+ struct reftable_table tab = { NULL };
+ struct reftable_ref_record *refs = NULL;
@@ reftable/stack.c (new)
+ goto done;
+
+ while (1) {
-+ struct reftable_ref_record ref = { 0 };
++ struct reftable_ref_record ref = { NULL };
+ err = reftable_iterator_next_ref(&it, &ref);
+ if (err > 0) {
+ break;
@@ reftable/stack.h (new)
+};
+
+int read_lines(const char *filename, char ***lines);
-+int stack_try_add(struct reftable_stack *st,
-+ int (*write_table)(struct reftable_writer *wr, void *arg),
-+ void *arg);
-+int stack_write_compact(struct reftable_stack *st, struct reftable_writer *wr,
-+ int first, int last,
-+ struct reftable_log_expiry_config *config);
-+int fastlog2(uint64_t sz);
-+int stack_check_addition(struct reftable_stack *st, const char *new_tab_name);
-+void reftable_addition_close(struct reftable_addition *add);
-+int reftable_stack_reload_maybe_reuse(struct reftable_stack *st,
-+ int reuse_open);
+
+struct segment {
+ int start, end;
@@ reftable/stack.h (new)
+ uint64_t bytes;
+};
+
++int fastlog2(uint64_t sz);
+struct segment *sizes_to_segments(int *seglen, uint64_t *sizes, int n);
+struct segment suggest_compaction_segment(uint64_t *sizes, int n);
+
@@ reftable/stack_test.c (new)
+ .update_index = 1,
+ .target = "master",
+ };
-+ struct reftable_ref_record dest = { 0 };
++ struct reftable_ref_record dest = { NULL };
+
+ assert(mkdtemp(dir));
+
@@ reftable/stack_test.c (new)
+ .update_index = 1,
+ .target = "master",
+ };
-+ struct reftable_ref_record dest = { 0 };
++ struct reftable_ref_record dest = { NULL };
+
+ assert(mkdtemp(dir));
+
@@ reftable/stack_test.c (new)
+ };
+ struct reftable_stack *st = NULL;
+ char dir[256] = "/tmp/stack_test.XXXXXX";
-+ struct reftable_ref_record refs[2] = { { 0 } };
-+ struct reftable_log_record logs[2] = { { 0 } };
++ struct reftable_ref_record refs[2] = { { NULL } };
++ struct reftable_log_record logs[2] = { { NULL } };
+ int N = ARRAY_SIZE(refs);
+
+ assert(mkdtemp(dir));
@@ reftable/stack_test.c (new)
+ assert_err(err);
+
+ for (i = 0; i < N; i++) {
-+ struct reftable_ref_record dest = { 0 };
++ struct reftable_ref_record dest = { NULL };
++
+ int err = reftable_stack_read_ref(st, refs[i].refname, &dest);
+ assert_err(err);
+ assert(reftable_ref_record_equal(&dest, refs + i, SHA1_SIZE));
@@ reftable/stack_test.c (new)
+ }
+
+ for (i = 0; i < N; i++) {
-+ struct reftable_log_record dest = { 0 };
++ struct reftable_log_record dest = { NULL };
+ int err = reftable_stack_read_log(st, refs[i].refname, &dest);
+ assert_err(err);
+ assert(reftable_log_record_equal(&dest, logs + i, SHA1_SIZE));
@@ reftable/stack_test.c (new)
+ struct reftable_write_options cfg = { 0 };
+ struct reftable_stack *st = NULL;
+ int err;
-+ struct reftable_ref_record refs[2] = { { 0 } };
-+ struct reftable_log_record logs[2] = { { 0 } };
++ struct reftable_ref_record refs[2] = { { NULL } };
++ struct reftable_log_record logs[2] = { { NULL } };
+ int N = ARRAY_SIZE(refs);
-+ struct reftable_ref_record dest = { 0 };
-+ struct reftable_log_record log_dest = { 0 };
++ struct reftable_ref_record dest = { NULL };
++ struct reftable_log_record log_dest = { NULL };
+
+ assert(mkdtemp(dir));
+
@@ reftable/stack_test.c (new)
+ struct reftable_stack *st32 = NULL;
+ struct reftable_write_options cfg_default = { 0 };
+ struct reftable_stack *st_default = NULL;
-+ struct reftable_ref_record dest = { 0 };
++ struct reftable_ref_record dest = { NULL };
+
+ assert(mkdtemp(dir));
+ err = reftable_new_stack(&st, dir, cfg);
@@ reftable/stack_test.c (new)
+ char dir[256] = "/tmp/stack.test_reflog_expire.XXXXXX";
+ struct reftable_write_options cfg = { 0 };
+ struct reftable_stack *st = NULL;
-+ struct reftable_log_record logs[20] = { { 0 } };
++ struct reftable_log_record logs[20] = { { NULL } };
+ int N = ARRAY_SIZE(logs) - 1;
+ int i = 0;
+ int err;
+ struct reftable_log_expiry_config expiry = {
+ .time = 10,
+ };
-+ struct reftable_log_record log = { 0 };
++ struct reftable_log_record log = { NULL };
+
+ assert(mkdtemp(dir));
+
13: b8729fee9e ! 13: c535f838d6 reftable: "test-tool dump-reftable" command.
@@ Makefile: REFTABLE_OBJS += reftable/writer.o
REFTABLE_TEST_OBJS += reftable/refname_test.o
REFTABLE_TEST_OBJS += reftable/reftable_test.o
+ ## reftable/iter.c ##
+@@ reftable/iter.c: void reftable_iterator_destroy(struct reftable_iterator *it)
+ int reftable_iterator_next_ref(struct reftable_iterator *it,
+ struct reftable_ref_record *ref)
+ {
+- struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ reftable_record_from_ref(&rec, ref);
+ return iterator_next(it, &rec);
+ }
+@@ reftable/iter.c: int reftable_iterator_next_ref(struct reftable_iterator *it,
+ int reftable_iterator_next_log(struct reftable_iterator *it,
+ struct reftable_log_record *log)
+ {
+- struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ reftable_record_from_log(&rec, log);
+ return iterator_next(it, &rec);
+ }
+@@ reftable/iter.c: static int filtering_ref_iterator_next(void *iter_arg,
+ }
+
+ if (fri->double_check) {
+- struct reftable_iterator it = { 0 };
++ struct reftable_iterator it = { NULL };
+
+ err = reftable_table_seek_ref(&fri->tab, &it,
+ ref->refname);
+
+ ## reftable/reader.c ##
+@@ reftable/reader.c: static int parse_footer(struct reftable_reader *r, uint8_t *footer,
+ int init_reader(struct reftable_reader *r, struct reftable_block_source *source,
+ const char *name)
+ {
+- struct reftable_block footer = { 0 };
+- struct reftable_block header = { 0 };
++ struct reftable_block footer = { NULL };
++ struct reftable_block header = { NULL };
+ int err = 0;
+
+ memset(r, 0, sizeof(struct reftable_reader));
+@@ reftable/reader.c: int reader_init_block_reader(struct reftable_reader *r, struct block_reader *br,
+ {
+ int32_t guess_block_size = r->block_size ? r->block_size :
+ DEFAULT_BLOCK_SIZE;
+- struct reftable_block block = { 0 };
++ struct reftable_block block = { NULL };
+ uint8_t block_typ = 0;
+ int err = 0;
+ uint32_t header_off = next_off ? 0 : header_size(r->version);
+@@ reftable/reader.c: static int reader_seek_indexed(struct reftable_reader *r,
+ struct reftable_record *rec)
+ {
+ struct reftable_index_record want_index = { .last_key = STRBUF_INIT };
+- struct reftable_record want_index_rec = { 0 };
++ struct reftable_record want_index_rec = { NULL };
+ struct reftable_index_record index_result = { .last_key = STRBUF_INIT };
+- struct reftable_record index_result_rec = { 0 };
++ struct reftable_record index_result_rec = { NULL };
+ struct table_iter index_iter = TABLE_ITER_INIT;
+ struct table_iter next = TABLE_ITER_INIT;
+ int err = 0;
+@@ reftable/reader.c: int reftable_reader_seek_ref(struct reftable_reader *r,
+ struct reftable_ref_record ref = {
+ .refname = (char *)name,
+ };
+- struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ reftable_record_from_ref(&rec, &ref);
+ return reader_seek(r, it, &rec);
+ }
+@@ reftable/reader.c: int reftable_reader_seek_log_at(struct reftable_reader *r,
+ .refname = (char *)name,
+ .update_index = update_index,
+ };
+- struct reftable_record rec = { 0 };
++ struct reftable_record rec = { NULL };
+ reftable_record_from_log(&rec, &log);
+ return reader_seek(r, it, &rec);
+ }
+@@ reftable/reader.c: static int reftable_reader_refs_for_indexed(struct reftable_reader *r,
+ .hash_prefix = oid,
+ .hash_prefix_len = r->object_id_len,
+ };
+- struct reftable_record want_rec = { 0 };
+- struct reftable_iterator oit = { 0 };
+- struct reftable_obj_record got = { 0 };
+- struct reftable_record got_rec = { 0 };
++ struct reftable_record want_rec = { NULL };
++ struct reftable_iterator oit = { NULL };
++ struct reftable_obj_record got = { NULL };
++ struct reftable_record got_rec = { NULL };
+ int err = 0;
+ struct indexed_table_ref_iter *itr = NULL;
+
+
## t/helper/test-reftable.c ##
@@ t/helper/test-reftable.c: int cmd__reftable(int argc, const char **argv)
tree_test_main(argc, argv);
--
gitgitgadget
next prev parent reply other threads:[~2020-10-01 16:11 UTC|newest]
Thread overview: 251+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-09-16 19:10 [PATCH 00/13] reftable library Han-Wen Nienhuys via GitGitGadget
2020-09-16 19:10 ` [PATCH 01/13] reftable: add LICENSE Han-Wen Nienhuys via GitGitGadget
2020-09-16 19:10 ` [PATCH 02/13] reftable: define the public API Han-Wen Nienhuys via GitGitGadget
2020-09-16 19:10 ` [PATCH 03/13] vcxproj: adjust for the reftable changes Johannes Schindelin via GitGitGadget
2020-09-16 19:10 ` [PATCH 04/13] reftable: add a barebones unittest framework Han-Wen Nienhuys via GitGitGadget
2020-09-16 19:10 ` [PATCH 05/13] reftable: utility functions Han-Wen Nienhuys via GitGitGadget
2020-09-16 19:10 ` [PATCH 06/13] reftable: (de)serialization for the polymorphic record type Han-Wen Nienhuys via GitGitGadget
2020-09-20 1:00 ` Junio C Hamano
2020-09-21 13:13 ` Han-Wen Nienhuys
2020-09-24 7:21 ` Jeff King
2020-09-24 7:31 ` Jeff King
2020-09-24 17:22 ` Junio C Hamano
2020-09-16 19:10 ` [PATCH 07/13] reftable: reading/writing blocks Han-Wen Nienhuys via GitGitGadget
2020-09-16 19:10 ` [PATCH 08/13] reftable: a generic binary tree implementation Han-Wen Nienhuys via GitGitGadget
2020-09-16 19:10 ` [PATCH 09/13] reftable: write reftable files Han-Wen Nienhuys via GitGitGadget
2020-09-16 19:10 ` [PATCH 10/13] reftable: read " Han-Wen Nienhuys via GitGitGadget
2020-09-16 19:10 ` [PATCH 11/13] reftable: file level tests Han-Wen Nienhuys via GitGitGadget
2020-09-16 19:10 ` [PATCH 12/13] reftable: rest of library Han-Wen Nienhuys via GitGitGadget
2020-09-16 19:10 ` [PATCH 13/13] reftable: "test-tool dump-reftable" command Han-Wen Nienhuys via GitGitGadget
2020-10-01 16:10 ` Han-Wen Nienhuys via GitGitGadget [this message]
2020-10-01 16:10 ` [PATCH v2 01/13] reftable: add LICENSE Han-Wen Nienhuys via GitGitGadget
2020-10-02 3:18 ` Jonathan Nieder
2020-10-01 16:10 ` [PATCH v2 02/13] reftable: define the public API Han-Wen Nienhuys via GitGitGadget
2020-10-02 3:58 ` Jonathan Nieder
2020-10-09 21:13 ` Emily Shaffer
2020-10-10 17:03 ` Han-Wen Nienhuys
2020-11-30 14:44 ` Han-Wen Nienhuys
2020-10-10 13:43 ` Han-Wen Nienhuys
2020-10-12 16:57 ` Jonathan Nieder
2020-11-30 14:55 ` Han-Wen Nienhuys
2020-10-08 1:41 ` Jonathan Tan
2020-10-10 16:57 ` Han-Wen Nienhuys
2020-10-01 16:10 ` [PATCH v2 03/13] vcxproj: adjust for the reftable changes Johannes Schindelin via GitGitGadget
2020-10-02 4:02 ` Jonathan Nieder
2020-10-02 11:43 ` Johannes Schindelin
2020-10-01 16:10 ` [PATCH v2 04/13] reftable: add a barebones unittest framework Han-Wen Nienhuys via GitGitGadget
2020-10-02 4:05 ` Jonathan Nieder
2020-10-08 1:45 ` Jonathan Tan
2020-10-08 22:31 ` Josh Steadmon
2020-10-01 16:10 ` [PATCH v2 05/13] reftable: utility functions Han-Wen Nienhuys via GitGitGadget
2020-10-02 4:12 ` Jonathan Nieder
2020-10-10 17:32 ` Han-Wen Nienhuys
2020-10-12 15:25 ` Jonathan Nieder
2020-10-12 17:05 ` Patrick Steinhardt
2020-10-12 17:45 ` Jonathan Nieder
2020-10-13 12:12 ` Johannes Schindelin
2020-10-13 15:47 ` Junio C Hamano
2020-10-15 11:46 ` Johannes Schindelin
2020-10-15 16:23 ` Junio C Hamano
2020-10-15 19:39 ` Johannes Schindelin
2020-10-16 9:15 ` Patrick Steinhardt
2020-10-02 14:01 ` Johannes Schindelin
2020-10-02 20:47 ` Junio C Hamano
2020-10-03 8:07 ` Johannes Schindelin
2020-10-08 1:48 ` Jonathan Tan
2020-10-10 17:28 ` Han-Wen Nienhuys
2020-10-11 10:52 ` Johannes Schindelin
2020-10-12 15:19 ` Jonathan Nieder
2020-10-12 18:44 ` Johannes Schindelin
2020-10-12 19:41 ` Jonathan Nieder
2020-10-12 20:27 ` Johannes Schindelin
2020-10-12 16:42 ` Junio C Hamano
2020-10-12 19:01 ` Johannes Schindelin
2020-10-23 9:13 ` Ævar Arnfjörð Bjarmason
2020-10-23 17:36 ` Junio C Hamano
2020-10-01 16:10 ` [PATCH v2 06/13] reftable: (de)serialization for the polymorphic record type Han-Wen Nienhuys via GitGitGadget
2020-10-01 19:23 ` Junio C Hamano
2020-10-01 19:59 ` Ramsay Jones
2020-10-01 16:10 ` [PATCH v2 07/13] reftable: reading/writing blocks Han-Wen Nienhuys via GitGitGadget
2020-10-01 16:10 ` [PATCH v2 08/13] reftable: a generic binary tree implementation Han-Wen Nienhuys via GitGitGadget
2020-10-01 16:10 ` [PATCH v2 09/13] reftable: write reftable files Han-Wen Nienhuys via GitGitGadget
2020-10-01 16:11 ` [PATCH v2 10/13] reftable: read " Han-Wen Nienhuys via GitGitGadget
2020-10-01 16:11 ` [PATCH v2 11/13] reftable: file level tests Han-Wen Nienhuys via GitGitGadget
2020-10-01 16:11 ` [PATCH v2 12/13] reftable: rest of library Han-Wen Nienhuys via GitGitGadget
2020-10-02 13:57 ` Johannes Schindelin
2020-10-02 17:08 ` Junio C Hamano
2020-10-04 18:39 ` Johannes Schindelin
2020-10-01 16:11 ` [PATCH v2 13/13] reftable: "test-tool dump-reftable" command Han-Wen Nienhuys via GitGitGadget
2020-11-26 19:42 ` [PATCH v3 00/16] reftable library Han-Wen Nienhuys via GitGitGadget
2020-11-26 19:42 ` [PATCH v3 01/16] move sleep_millisec to git-compat-util.h Han-Wen Nienhuys via GitGitGadget
2020-11-26 19:42 ` [PATCH v3 02/16] init-db: set the_repository->hash_algo early on Han-Wen Nienhuys via GitGitGadget
2020-11-27 10:22 ` Ævar Arnfjörð Bjarmason
2020-11-26 19:42 ` [PATCH v3 03/16] reftable: add LICENSE Han-Wen Nienhuys via GitGitGadget
2020-11-27 10:23 ` Ævar Arnfjörð Bjarmason
2020-11-30 11:26 ` Han-Wen Nienhuys
2020-11-30 20:25 ` Han-Wen Nienhuys
2020-11-30 21:21 ` Felipe Contreras
2020-12-01 9:51 ` Han-Wen Nienhuys
2020-12-01 10:38 ` Felipe Contreras
2020-12-01 11:45 ` Ævar Arnfjörð Bjarmason
2020-12-01 13:34 ` Han-Wen Nienhuys
2020-12-01 23:13 ` Felipe Contreras
2020-12-01 23:03 ` Felipe Contreras
2020-11-26 19:42 ` [PATCH v3 04/16] reftable: add error related functionality Han-Wen Nienhuys via GitGitGadget
2020-11-27 9:13 ` Felipe Contreras
2020-11-27 10:25 ` Ævar Arnfjörð Bjarmason
2020-11-30 11:27 ` Han-Wen Nienhuys
2020-11-26 19:42 ` [PATCH v3 05/16] reftable: utility functions Han-Wen Nienhuys via GitGitGadget
2020-11-27 10:18 ` Felipe Contreras
2020-11-27 10:33 ` Ævar Arnfjörð Bjarmason
2020-11-26 19:42 ` [PATCH v3 06/16] reftable: add blocksource, an abstraction for random access reads Han-Wen Nienhuys via GitGitGadget
2020-11-26 19:42 ` [PATCH v3 07/16] reftable: (de)serialization for the polymorphic record type Han-Wen Nienhuys via GitGitGadget
2020-11-26 19:42 ` [PATCH v3 08/16] reftable: reading/writing blocks Han-Wen Nienhuys via GitGitGadget
2020-11-26 19:42 ` [PATCH v3 09/16] reftable: a generic binary tree implementation Han-Wen Nienhuys via GitGitGadget
2020-11-26 19:42 ` [PATCH v3 10/16] reftable: write reftable files Han-Wen Nienhuys via GitGitGadget
2020-11-26 19:42 ` [PATCH v3 11/16] reftable: read " Han-Wen Nienhuys via GitGitGadget
2020-11-26 19:42 ` [PATCH v3 12/16] reftable: reftable file level tests Han-Wen Nienhuys via GitGitGadget
2020-11-26 19:42 ` [PATCH v3 13/16] reftable: rest of library Han-Wen Nienhuys via GitGitGadget
2020-11-26 19:42 ` [PATCH v3 14/16] Reftable support for git-core Han-Wen Nienhuys via GitGitGadget
2020-11-27 10:59 ` Ævar Arnfjörð Bjarmason
2020-11-26 19:42 ` [PATCH v3 15/16] git-prompt: prepare for reftable refs backend SZEDER Gábor via GitGitGadget
2020-11-26 19:42 ` [PATCH v3 16/16] Add "test-tool dump-reftable" command Han-Wen Nienhuys via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 00/15] reftable library Han-Wen Nienhuys via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 01/15] init-db: set the_repository->hash_algo early on Han-Wen Nienhuys via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 02/15] reftable: add LICENSE Han-Wen Nienhuys via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 03/15] reftable: add error related functionality Han-Wen Nienhuys via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 04/15] reftable: utility functions Han-Wen Nienhuys via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 05/15] reftable: add blocksource, an abstraction for random access reads Han-Wen Nienhuys via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 06/15] reftable: (de)serialization for the polymorphic record type Han-Wen Nienhuys via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 07/15] reftable: reading/writing blocks Han-Wen Nienhuys via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 08/15] reftable: a generic binary tree implementation Han-Wen Nienhuys via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 09/15] reftable: write reftable files Han-Wen Nienhuys via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 10/15] reftable: read " Han-Wen Nienhuys via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 11/15] reftable: reftable file level tests Han-Wen Nienhuys via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 12/15] reftable: rest of library Han-Wen Nienhuys via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 13/15] Reftable support for git-core Han-Wen Nienhuys via GitGitGadget
2021-01-21 15:55 ` Ævar Arnfjörð Bjarmason
2021-01-21 16:14 ` Han-Wen Nienhuys
2021-01-21 16:21 ` Han-Wen Nienhuys
2021-01-26 13:44 ` Ævar Arnfjörð Bjarmason
2021-04-23 10:22 ` Han-Wen Nienhuys
2021-04-26 13:23 ` Ævar Arnfjörð Bjarmason
2021-04-26 16:17 ` Han-Wen Nienhuys
2021-04-28 16:32 ` Ævar Arnfjörð Bjarmason
2021-04-28 17:40 ` Han-Wen Nienhuys
2021-02-22 0:41 ` [PATCH] refs: introduce API function to write invalid null ref Stefan Beller
2021-02-22 1:20 ` Eric Sunshine
2021-02-22 3:09 ` Eric Sunshine
2021-02-22 18:38 ` Han-Wen Nienhuys
2020-12-09 14:00 ` [PATCH v4 14/15] git-prompt: prepare for reftable refs backend SZEDER Gábor via GitGitGadget
2020-12-09 14:00 ` [PATCH v4 15/15] Add "test-tool dump-reftable" command Han-Wen Nienhuys via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 00/15] reftable library Han-Wen Nienhuys via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 01/15] init-db: set the_repository->hash_algo early on Han-Wen Nienhuys via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 02/15] reftable: add LICENSE Han-Wen Nienhuys via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 03/15] reftable: add error related functionality Han-Wen Nienhuys via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 04/15] reftable: utility functions Han-Wen Nienhuys via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 05/15] reftable: add blocksource, an abstraction for random access reads Han-Wen Nienhuys via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 06/15] reftable: (de)serialization for the polymorphic record type Han-Wen Nienhuys via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 07/15] reftable: reading/writing blocks Han-Wen Nienhuys via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 08/15] reftable: a generic binary tree implementation Han-Wen Nienhuys via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 09/15] reftable: write reftable files Han-Wen Nienhuys via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 10/15] reftable: read " Han-Wen Nienhuys via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 11/15] reftable: reftable file level tests Han-Wen Nienhuys via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 12/15] reftable: rest of library Han-Wen Nienhuys via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 13/15] Reftable support for git-core Han-Wen Nienhuys via GitGitGadget
2021-03-23 11:40 ` Derrick Stolee
2021-03-23 12:20 ` Ævar Arnfjörð Bjarmason
2021-03-23 20:14 ` Junio C Hamano
2021-03-23 20:12 ` Junio C Hamano
2021-03-12 20:19 ` [PATCH v5 14/15] git-prompt: prepare for reftable refs backend SZEDER Gábor via GitGitGadget
2021-03-12 20:19 ` [PATCH v5 15/15] Add "test-tool dump-reftable" command Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 00/20] reftable library Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 01/20] init-db: set the_repository->hash_algo early on Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 02/20] reftable: add LICENSE Han-Wen Nienhuys via GitGitGadget
2021-04-13 7:28 ` Ævar Arnfjörð Bjarmason
2021-04-13 10:50 ` Han-Wen Nienhuys
2021-04-13 13:41 ` Ævar Arnfjörð Bjarmason
2021-04-12 19:25 ` [PATCH v6 03/20] reftable: add error related functionality Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 04/20] reftable: utility functions Han-Wen Nienhuys via GitGitGadget
2021-04-13 8:02 ` Ævar Arnfjörð Bjarmason
2021-04-13 10:58 ` Han-Wen Nienhuys
2021-04-13 12:56 ` Ævar Arnfjörð Bjarmason
2021-04-13 13:14 ` Ævar Arnfjörð Bjarmason
2021-04-15 15:00 ` Han-Wen Nienhuys
2021-04-12 19:25 ` [PATCH v6 05/20] reftable: add blocksource, an abstraction for random access reads Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 06/20] reftable: (de)serialization for the polymorphic record type Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 07/20] reftable: reading/writing blocks Han-Wen Nienhuys via GitGitGadget
2021-04-12 21:40 ` Junio C Hamano
2021-04-13 8:19 ` Ævar Arnfjörð Bjarmason
2021-04-15 8:57 ` Han-Wen Nienhuys
2021-04-12 19:25 ` [PATCH v6 08/20] reftable: a generic binary tree implementation Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 09/20] reftable: write reftable files Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 10/20] reftable: generic interface to tables Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 11/20] reftable: read reftable files Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 12/20] reftable: reftable file level tests Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 13/20] reftable: add a heap-based priority queue for reftable records Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 14/20] reftable: add merged table view Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 15/20] reftable: implement refname validation Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 16/20] reftable: implement stack, a mutable database of reftable files Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 17/20] reftable: add dump utility Han-Wen Nienhuys via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 18/20] Reftable support for git-core Han-Wen Nienhuys via GitGitGadget
2021-04-13 7:18 ` Ævar Arnfjörð Bjarmason
2021-04-14 16:44 ` Han-Wen Nienhuys
2021-04-16 14:55 ` Ævar Arnfjörð Bjarmason
2021-04-16 18:47 ` Junio C Hamano
2021-04-12 19:25 ` [PATCH v6 19/20] git-prompt: prepare for reftable refs backend SZEDER Gábor via GitGitGadget
2021-04-12 19:25 ` [PATCH v6 20/20] Add "test-tool dump-reftable" command Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 00/28] reftable library Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 01/28] refs: ref_iterator_peel returns boolean, rather than peel_status Han-Wen Nienhuys via GitGitGadget
2021-04-20 18:47 ` Junio C Hamano
2021-04-21 10:15 ` Han-Wen Nienhuys
2021-04-21 23:28 ` Junio C Hamano
2021-04-19 11:37 ` [PATCH v7 02/28] refs: document reflog_expire_fn's flag argument Han-Wen Nienhuys via GitGitGadget
2021-04-20 19:34 ` Junio C Hamano
2021-04-27 15:21 ` Han-Wen Nienhuys
2021-04-19 11:37 ` [PATCH v7 03/28] refs/debug: trace into reflog expiry too Han-Wen Nienhuys via GitGitGadget
2021-04-20 19:41 ` Junio C Hamano
2021-04-22 17:27 ` Han-Wen Nienhuys
2021-04-19 11:37 ` [PATCH v7 04/28] hash.h: provide constants for the hash IDs Han-Wen Nienhuys via GitGitGadget
2021-04-20 19:49 ` Junio C Hamano
2021-04-21 1:04 ` brian m. carlson
2021-04-21 9:43 ` Han-Wen Nienhuys
2021-07-22 8:31 ` Han-Wen Nienhuys
2021-04-19 11:37 ` [PATCH v7 05/28] init-db: set the_repository->hash_algo early on Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 06/28] reftable: add LICENSE Han-Wen Nienhuys via GitGitGadget
2021-04-21 7:48 ` Ævar Arnfjörð Bjarmason
2021-04-21 9:15 ` Han-Wen Nienhuys
2021-04-19 11:37 ` [PATCH v7 07/28] reftable: add error related functionality Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 08/28] reftable: utility functions Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 09/28] reftable: add blocksource, an abstraction for random access reads Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 10/28] reftable: (de)serialization for the polymorphic record type Han-Wen Nienhuys via GitGitGadget
2021-05-04 17:23 ` Andrzej Hunt
2021-05-18 13:12 ` Han-Wen Nienhuys
2021-04-19 11:37 ` [PATCH v7 11/28] Provide zlib's uncompress2 from compat/zlib-compat.c Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 12/28] reftable: reading/writing blocks Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 13/28] reftable: a generic binary tree implementation Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 14/28] reftable: write reftable files Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 15/28] reftable: generic interface to tables Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 16/28] reftable: read reftable files Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 17/28] reftable: reftable file level tests Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 18/28] reftable: add a heap-based priority queue for reftable records Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 19/28] reftable: add merged table view Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 20/28] reftable: implement refname validation Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 21/28] reftable: implement stack, a mutable database of reftable files Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 22/28] reftable: add dump utility Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 23/28] Reftable support for git-core Han-Wen Nienhuys via GitGitGadget
2021-04-20 22:44 ` Junio C Hamano
2021-04-21 10:19 ` Han-Wen Nienhuys
2021-04-21 23:22 ` Junio C Hamano
2021-05-04 17:24 ` Andrzej Hunt
2021-05-18 13:18 ` Han-Wen Nienhuys
2021-05-18 13:30 ` Han-Wen Nienhuys
2021-04-19 11:37 ` [PATCH v7 24/28] git-prompt: prepare for reftable refs backend SZEDER Gábor via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 25/28] Add "test-tool dump-reftable" command Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 26/28] t1301: document what needs to be done for REFTABLE Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 27/28] t1401,t2011: parameterize HEAD.lock " Han-Wen Nienhuys via GitGitGadget
2021-04-19 11:37 ` [PATCH v7 28/28] t1404: annotate test cases with REFFILES Han-Wen Nienhuys via GitGitGadget
2021-04-21 7:45 ` [PATCH v7 00/28] reftable library Ævar Arnfjörð Bjarmason
2021-04-21 9:52 ` Han-Wen Nienhuys
2021-04-21 11:21 ` Ævar Arnfjörð Bjarmason
2021-04-26 17:59 ` Han-Wen Nienhuys
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=pull.847.v2.git.git.1601568663.gitgitgadget@gmail.com \
--to=gitgitgadget@gmail.com \
--cc=git@vger.kernel.org \
--cc=hanwen@google.com \
--cc=hanwenn@gmail.com \
--cc=peff@peff.net \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.