kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

t/helper: inline printing of reftable records 

Move printing of reftable records into the "dump-reftable" helper. This
follows the same reasoning as the preceding commit.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
Patrick Steinhardt 2024-08-22 08:35:18 +02:00 committed by Junio C Hamano
parent 64a5b7a8ca
commit 42c424d69d
4 changed files with 71 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
reftable/record.c
View File

@ -259,58 +259,6 @@ static void reftable_ref_record_copy_from(void *rec, const void *src_rec,
}
}

static char hexdigit(int c)
{
if (c <= 9)
return '0' + c;
return 'a' + (c - 10);
}

static void hex_format(char *dest, const unsigned char *src, int hash_size)
{
assert(hash_size > 0);
if (src) {
int i = 0;
for (i = 0; i < hash_size; i++) {
dest[2 * i] = hexdigit(src[i] >> 4);
dest[2 * i + 1] = hexdigit(src[i] & 0xf);
}
dest[2 * hash_size] = 0;
}
}

static void reftable_ref_record_print_sz(const struct reftable_ref_record *ref,
int hash_size)
{
char hex[GIT_MAX_HEXSZ + 1] = { 0 }; /* BUG */
printf("ref{%s(%" PRIu64 ") ", ref->refname, ref->update_index);
switch (ref->value_type) {
case REFTABLE_REF_SYMREF:
printf("=> %s", ref->value.symref);
break;
case REFTABLE_REF_VAL2:
hex_format(hex, ref->value.val2.value, hash_size);
printf("val 2 %s", hex);
hex_format(hex, ref->value.val2.target_value,
hash_size);
printf("(T %s)", hex);
break;
case REFTABLE_REF_VAL1:
hex_format(hex, ref->value.val1, hash_size);
printf("val 1 %s", hex);
break;
case REFTABLE_REF_DELETION:
printf("delete");
break;
}
printf("}\n");
}

void reftable_ref_record_print(const struct reftable_ref_record *ref,
uint32_t hash_id) {
reftable_ref_record_print_sz(ref, hash_size(hash_id));
}

static void reftable_ref_record_release_void(void *rec)
{
reftable_ref_record_release(rec);
@ -480,12 +428,6 @@ static int reftable_ref_record_cmp_void(const void *_a, const void *_b)
return strcmp(a->refname, b->refname);
}

static void reftable_ref_record_print_void(const void *rec,
int hash_size)
{
reftable_ref_record_print_sz((struct reftable_ref_record *) rec, hash_size);
}

static struct reftable_record_vtable reftable_ref_record_vtable = {
.key = &reftable_ref_record_key,
.type = BLOCK_TYPE_REF,
@ -497,7 +439,6 @@ static struct reftable_record_vtable reftable_ref_record_vtable = {
.is_deletion = &reftable_ref_record_is_deletion_void,
.equal = &reftable_ref_record_equal_void,
.cmp = &reftable_ref_record_cmp_void,
.print = &reftable_ref_record_print_void,
};

static void reftable_obj_record_key(const void *r, struct strbuf *dest)
@ -516,21 +457,6 @@ static void reftable_obj_record_release(void *rec)
memset(obj, 0, sizeof(struct reftable_obj_record));
}

static void reftable_obj_record_print(const void *rec, int hash_size)
{
const struct reftable_obj_record *obj = rec;
char hex[GIT_MAX_HEXSZ + 1] = { 0 };
struct strbuf offset_str = STRBUF_INIT;
int i;

for (i = 0; i < obj->offset_len; i++)
strbuf_addf(&offset_str, "%" PRIu64 " ", obj->offsets[i]);
hex_format(hex, obj->hash_prefix, obj->hash_prefix_len);
printf("prefix %s (len %d), offsets [%s]\n",
hex, obj->hash_prefix_len, offset_str.buf);
strbuf_release(&offset_str);
}

static void reftable_obj_record_copy_from(void *rec, const void *src_rec,
int hash_size)
{
@ -701,41 +627,8 @@ static struct reftable_record_vtable reftable_obj_record_vtable = {
.is_deletion = &not_a_deletion,
.equal = &reftable_obj_record_equal_void,
.cmp = &reftable_obj_record_cmp_void,
.print = &reftable_obj_record_print,
};

static void reftable_log_record_print_sz(struct reftable_log_record *log,
int hash_size)
{
char hex[GIT_MAX_HEXSZ + 1] = { 0 };

switch (log->value_type) {
case REFTABLE_LOG_DELETION:
printf("log{%s(%" PRIu64 ") delete\n", log->refname,
log->update_index);
break;
case REFTABLE_LOG_UPDATE:
printf("log{%s(%" PRIu64 ") %s <%s> %" PRIu64 " %04d\n",
log->refname, log->update_index,
log->value.update.name ? log->value.update.name : "",
log->value.update.email ? log->value.update.email : "",
log->value.update.time,
log->value.update.tz_offset);
hex_format(hex, log->value.update.old_hash, hash_size);
printf("%s => ", hex);
hex_format(hex, log->value.update.new_hash, hash_size);
printf("%s\n\n%s\n}\n", hex,
log->value.update.message ? log->value.update.message : "");
break;
}
}

void reftable_log_record_print(struct reftable_log_record *log,
uint32_t hash_id)
{
reftable_log_record_print_sz(log, hash_size(hash_id));
}

static void reftable_log_record_key(const void *r, struct strbuf *dest)
{
const struct reftable_log_record *rec =
@ -1039,11 +932,6 @@ static int reftable_log_record_is_deletion_void(const void *p)
(const struct reftable_log_record *)p);
}

static void reftable_log_record_print_void(const void *rec, int hash_size)
{
reftable_log_record_print_sz((struct reftable_log_record*)rec, hash_size);
}

static struct reftable_record_vtable reftable_log_record_vtable = {
.key = &reftable_log_record_key,
.type = BLOCK_TYPE_LOG,
@ -1055,7 +943,6 @@ static struct reftable_record_vtable reftable_log_record_vtable = {
.is_deletion = &reftable_log_record_is_deletion_void,
.equal = &reftable_log_record_equal_void,
.cmp = &reftable_log_record_cmp_void,
.print = &reftable_log_record_print_void,
};

static void reftable_index_record_key(const void *r, struct strbuf *dest)
@ -1137,13 +1024,6 @@ static int reftable_index_record_cmp(const void *_a, const void *_b)
return strbuf_cmp(&a->last_key, &b->last_key);
}

static void reftable_index_record_print(const void *rec, int hash_size)
{
const struct reftable_index_record *idx = rec;
/* TODO: escape null chars? */
printf("\"%s\" %" PRIu64 "\n", idx->last_key.buf, idx->offset);
}

static struct reftable_record_vtable reftable_index_record_vtable = {
.key = &reftable_index_record_key,
.type = BLOCK_TYPE_INDEX,
@ -1155,7 +1035,6 @@ static struct reftable_record_vtable reftable_index_record_vtable = {
.is_deletion = &not_a_deletion,
.equal = &reftable_index_record_equal,
.cmp = &reftable_index_record_cmp,
.print = &reftable_index_record_print,
};

void reftable_record_key(struct reftable_record *rec, struct strbuf *dest)
@ -1334,9 +1213,3 @@ void reftable_record_init(struct reftable_record *rec, uint8_t typ)
BUG("unhandled record type");
}
}

void reftable_record_print(struct reftable_record *rec, int hash_size)
{
printf("'%c': ", rec->type);
reftable_record_vtable(rec)->print(reftable_record_data(rec), hash_size);
}

1
reftable/record.h
View File

@ -136,7 +136,6 @@ void 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);
int reftable_record_equal(struct reftable_record *a, struct reftable_record *b, int hash_size);
void reftable_record_print(struct reftable_record *rec, int hash_size);
void reftable_record_key(struct reftable_record *rec, struct strbuf *dest);
void reftable_record_copy_from(struct reftable_record *rec,
struct reftable_record *src, int hash_size);

8
reftable/reftable-record.h
View File

@ -60,10 +60,6 @@ const unsigned char *reftable_ref_record_val2(const struct reftable_ref_record *
/* returns whether 'ref' represents a deletion */
int reftable_ref_record_is_deletion(const struct reftable_ref_record *ref);

/* prints a reftable_ref_record onto stdout. Useful for debugging. */
void reftable_ref_record_print(const struct reftable_ref_record *ref,
uint32_t hash_id);

/* frees and nulls all pointer values inside `ref`. */
void reftable_ref_record_release(struct reftable_ref_record *ref);

@ -111,8 +107,4 @@ void reftable_log_record_release(struct reftable_log_record *log);
int reftable_log_record_equal(const struct reftable_log_record *a,
const struct reftable_log_record *b, int hash_size);

/* dumps a reftable_log_record on stdout, for debugging/testing. */
void reftable_log_record_print(struct reftable_log_record *log,
uint32_t hash_id);

#endif

81
t/helper/test-reftable.c
View File

@ -30,12 +30,33 @@ static void print_help(void)
"\n");
}

static char hexdigit(int c)
{
if (c <= 9)
return '0' + c;
return 'a' + (c - 10);
}

static void hex_format(char *dest, const unsigned char *src, int hash_size)
{
assert(hash_size > 0);
if (src) {
int i = 0;
for (i = 0; i < hash_size; i++) {
dest[2 * i] = hexdigit(src[i] >> 4);
dest[2 * i + 1] = hexdigit(src[i] & 0xf);
}
dest[2 * hash_size] = 0;
}
}

static int dump_table(struct reftable_table *tab)
{
struct reftable_iterator it = { NULL };
struct reftable_ref_record ref = { NULL };
struct reftable_log_record log = { NULL };
uint32_t hash_id = reftable_table_hash_id(tab);
int hash_len = hash_size(hash_id);
int err;

reftable_table_init_ref_iter(tab, &it);
@ -45,14 +66,35 @@ static int dump_table(struct reftable_table *tab)
return err;

while (1) {
char hex[GIT_MAX_HEXSZ + 1] = { 0 }; /* BUG */

err = reftable_iterator_next_ref(&it, &ref);
if (err > 0) {
if (err > 0)
break;
if (err < 0)
return err;

printf("ref{%s(%" PRIu64 ") ", ref.refname, ref.update_index);
switch (ref.value_type) {
case REFTABLE_REF_SYMREF:
printf("=> %s", ref.value.symref);
break;
case REFTABLE_REF_VAL2:
hex_format(hex, ref.value.val2.value, hash_len);
printf("val 2 %s", hex);
hex_format(hex, ref.value.val2.target_value,
hash_len);
printf("(T %s)", hex);
break;
case REFTABLE_REF_VAL1:
hex_format(hex, ref.value.val1, hash_len);
printf("val 1 %s", hex);
break;
case REFTABLE_REF_DELETION:
printf("delete");
break;
}
if (err < 0) {
return err;
}
reftable_ref_record_print(&ref, hash_id);
printf("}\n");
}
reftable_iterator_destroy(&it);
reftable_ref_record_release(&ref);
@ -64,14 +106,33 @@ static int dump_table(struct reftable_table *tab)
return err;

while (1) {
char hex[GIT_MAX_HEXSZ + 1] = { 0 };

err = reftable_iterator_next_log(&it, &log);
if (err > 0) {
if (err > 0)
break;
if (err < 0)
return err;

switch (log.value_type) {
case REFTABLE_LOG_DELETION:
printf("log{%s(%" PRIu64 ") delete\n", log.refname,
log.update_index);
break;
case REFTABLE_LOG_UPDATE:
printf("log{%s(%" PRIu64 ") %s <%s> %" PRIu64 " %04d\n",
log.refname, log.update_index,
log.value.update.name ? log.value.update.name : "",
log.value.update.email ? log.value.update.email : "",
log.value.update.time,
log.value.update.tz_offset);
hex_format(hex, log.value.update.old_hash, hash_len);
printf("%s => ", hex);
hex_format(hex, log.value.update.new_hash, hash_len);
printf("%s\n\n%s\n}\n", hex,
log.value.update.message ? log.value.update.message : "");
break;
}
if (err < 0) {
return err;
}
reftable_log_record_print(&log, hash_id);
}
reftable_iterator_destroy(&it);
reftable_log_record_release(&log);