From 2d48cbaec62c935afb427051ea85e0245f95f773 Mon Sep 17 00:00:00 2001 From: libretroadmin Date: Sat, 18 Feb 2023 18:04:55 +0100 Subject: [PATCH] (libretro-db) Cleanups/style nits --- libretro-db/bintree.c | 20 ++-- libretro-db/libretrodb.c | 42 ++----- libretro-db/query.c | 98 ++++++++-------- libretro-db/rmsgpack.c | 80 ++++++------- libretro-db/rmsgpack_dom.c | 229 ++++++++++++++++++------------------- 5 files changed, 216 insertions(+), 253 deletions(-) diff --git a/libretro-db/bintree.c b/libretro-db/bintree.c index 569b39e4e7..225797e1cf 100644 --- a/libretro-db/bintree.c +++ b/libretro-db/bintree.c @@ -104,9 +104,6 @@ static int bintree_iterate_internal(struct bintree_node *n, static void bintree_free_node(struct bintree_node *n) { - if (!n) - return; - if (n->value == NIL_NODE) { free(n); @@ -114,8 +111,10 @@ static void bintree_free_node(struct bintree_node *n) } n->value = NULL; - bintree_free_node(n->left); - bintree_free_node(n->right); + if (n->left) + bintree_free_node(n->left); + if (n->right) + bintree_free_node(n->right); free(n); } @@ -137,16 +136,15 @@ bintree_t *bintree_new(bintree_cmp_func cmp, void *ctx) if (!t) return NULL; - t->root = bintree_new_nil_node(NULL); - t->cmp = cmp; - t->ctx = ctx; + t->root = bintree_new_nil_node(NULL); + t->cmp = cmp; + t->ctx = ctx; return t; } void bintree_free(bintree_t *t) { - if (!t) - return; - bintree_free_node(t->root); + if (t && t->root) + bintree_free_node(t->root); } diff --git a/libretro-db/libretrodb.c b/libretro-db/libretrodb.c index 81f6c45478..e0a8332ba6 100644 --- a/libretro-db/libretrodb.c +++ b/libretro-db/libretrodb.c @@ -86,18 +86,6 @@ struct libretrodb_cursor int eof; }; -static int libretrodb_read_metadata(RFILE *fd, libretrodb_metadata_t *md) -{ - return rmsgpack_dom_read_into(fd, "count", &md->count, NULL); -} - -static int libretrodb_write_metadata(RFILE *fd, libretrodb_metadata_t *md) -{ - rmsgpack_write_map_header(fd, 1); - rmsgpack_write_string(fd, "count", STRLEN_CONST("count")); - return rmsgpack_write_uint(fd, md->count); -} - static int libretrodb_validate_document(const struct rmsgpack_dom_value *doc) { unsigned i; @@ -171,7 +159,9 @@ int libretrodb_create(RFILE *fd, libretrodb_value_provider value_provider, header.metadata_offset = swap_if_little64(filestream_tell(fd)); md.count = item_count; - libretrodb_write_metadata(fd, &md); + rmsgpack_write_map_header(fd, 1); + rmsgpack_write_string(fd, "count", STRLEN_CONST("count")); + rmsgpack_write_uint(fd, md.count); filestream_seek(fd, root, RETRO_VFS_SEEK_POSITION_START); filestream_write(fd, &header, sizeof(header)); clean: @@ -236,7 +226,7 @@ int libretrodb_open(const char *path, libretrodb_t *db) filestream_seek(fd, (ssize_t)header.metadata_offset, RETRO_VFS_SEEK_POSITION_START); - if (libretrodb_read_metadata(fd, &md) < 0) + if (rmsgpack_dom_read_into(fd, "count", &md.count, NULL) < 0) goto error; db->count = md.count; @@ -363,8 +353,7 @@ int libretrodb_cursor_read_item(libretrodb_cursor_t *cursor, return EOF; retry: - rv = rmsgpack_dom_read(cursor->fd, out); - if (rv < 0) + if ((rv = rmsgpack_dom_read(cursor->fd, out)) < 0) return rv; if (out->type == RDT_NULL) @@ -455,11 +444,6 @@ static int node_iter(void *value, void *ctx) return -1; } -static uint64_t libretrodb_tell(libretrodb_t *db) -{ - return filestream_tell(db->fd); -} - static int node_compare(const void *a, const void *b, void *ctx) { return memcmp(a, b, *(uint8_t *)ctx); @@ -477,7 +461,7 @@ int libretrodb_create_index(libretrodb_t *db, void *buff = NULL; uint64_t *buff_u64 = NULL; uint8_t field_size = 0; - uint64_t item_loc = libretrodb_tell(db); + uint64_t item_loc = filestream_tell(db->fd); bintree_t *tree = bintree_new(node_compare, &field_size); item.type = RDT_NULL; @@ -530,7 +514,7 @@ int libretrodb_create_index(libretrodb_t *db, } buff = NULL; rmsgpack_dom_value_free(&item); - item_loc = libretrodb_tell(db); + item_loc = filestream_tell(db->fd); } filestream_seek(db->fd, 0, RETRO_VFS_SEEK_POSITION_END); @@ -576,10 +560,8 @@ libretrodb_cursor_t *libretrodb_cursor_new(void) void libretrodb_cursor_free(libretrodb_cursor_t *dbc) { - if (!dbc) - return; - - free(dbc); + if (dbc) + free(dbc); } libretrodb_t *libretrodb_new(void) @@ -600,8 +582,6 @@ libretrodb_t *libretrodb_new(void) void libretrodb_free(libretrodb_t *db) { - if (!db) - return; - - free(db); + if (db) + free(db); } diff --git a/libretro-db/query.c b/libretro-db/query.c index 3775c8dc7a..7208267fe5 100644 --- a/libretro-db/query.c +++ b/libretro-db/query.c @@ -51,7 +51,7 @@ struct buffer enum argument_type { - AT_FUNCTION, + AT_FUNCTION = 0, AT_VALUE }; @@ -107,8 +107,8 @@ static struct rmsgpack_dom_value query_func_is_true( { struct rmsgpack_dom_value res; - res.type = RDT_BOOL; - res.val.bool_ = 0; + res.type = RDT_BOOL; + res.val.bool_ = 0; if (!(argc > 0 || input.type != RDT_BOOL)) res.val.bool_ = input.val.bool_; @@ -122,12 +122,12 @@ static struct rmsgpack_dom_value func_equals( { struct rmsgpack_dom_value res; - res.type = RDT_BOOL; - res.val.bool_ = 0; + res.type = RDT_BOOL; + res.val.bool_ = 0; if (argc == 1) { - struct argument arg = argv[0]; + struct argument arg = argv[0]; if (arg.type == AT_VALUE) { @@ -137,7 +137,7 @@ static struct rmsgpack_dom_value func_equals( arg.a.value.type = RDT_UINT; arg.a.value.val.uint_ = arg.a.value.val.int_; } - res.val.bool_ = (rmsgpack_dom_value_cmp(&input, &arg.a.value) == 0); + res.val.bool_ = (rmsgpack_dom_value_cmp(&input, &arg.a.value) == 0); } } @@ -249,13 +249,12 @@ static struct rmsgpack_dom_value query_func_glob( return res; if (argv[0].type != AT_VALUE || argv[0].a.value.type != RDT_STRING) return res; - if (input.type != RDT_STRING) - return res; - res.val.bool_ = rl_fnmatch( - argv[0].a.value.val.string.buff, - input.val.string.buff, - 0 - ) == 0; + if (input.type == RDT_STRING) + res.val.bool_ = rl_fnmatch( + argv[0].a.value.val.string.buff, + input.val.string.buff, + 0 + ) == 0; return res; } @@ -307,15 +306,10 @@ static struct buffer query_parse_integer( struct rmsgpack_dom_value *value, const char **error) { - bool test = false; - value->type = RDT_INT; - - test = (sscanf(buff.data + buff.offset, - STRING_REP_INT64, - (int64_t*)&value->val.int_) == 0); - - if (test) + if (sscanf(buff.data + buff.offset, + STRING_REP_INT64, + (int64_t*)&value->val.int_) == 0) { snprintf(s, len, "%" PRIu64 "::Expected number", @@ -393,16 +387,15 @@ static struct buffer query_parse_string( char terminator = '\0'; char c = '\0'; int is_binstr = 0; - buff = query_get_char(s, len,buff, &terminator, error); + buff = query_get_char(s, len,buff, &terminator, error); if (*error) return buff; if (terminator == 'b') { - is_binstr = 1; - buff = query_get_char(s, len, - buff, &terminator, error); + is_binstr = 1; + buff = query_get_char(s, len, buff, &terminator, error); } if (terminator != '"' && terminator != '\'') @@ -733,8 +726,6 @@ static struct rmsgpack_dom_value query_func_all_map( struct rmsgpack_dom_value input, unsigned argc, const struct argument *argv) { - unsigned i; - struct argument arg; struct rmsgpack_dom_value res; struct rmsgpack_dom_value nil_value; struct rmsgpack_dom_value *value = NULL; @@ -750,34 +741,35 @@ static struct rmsgpack_dom_value query_func_all_map( return res; } - if (input.type != RDT_MAP) - return res; - - for (i = 0; i < argc; i += 2) + if (input.type == RDT_MAP) { - arg = argv[i]; - if (arg.type != AT_VALUE) + unsigned i; + for (i = 0; i < argc; i += 2) { - res.val.bool_ = 0; - return res; + struct argument arg = argv[i]; + if (arg.type != AT_VALUE) + { + res.val.bool_ = 0; + return res; + } + /* All missing fields are nil */ + if (!(value = rmsgpack_dom_value_map_value(&input, &arg.a.value))) + value = &nil_value; + arg = argv[i + 1]; + if (arg.type == AT_VALUE) + res = func_equals(*value, 1, &arg); + else + { + res = query_func_is_true(arg.a.invocation.func( + *value, + arg.a.invocation.argc, + arg.a.invocation.argv + ), 0, NULL); + value = NULL; + } + if (!res.val.bool_) + break; } - value = rmsgpack_dom_value_map_value(&input, &arg.a.value); - if (!value) /* All missing fields are nil */ - value = &nil_value; - arg = argv[i + 1]; - if (arg.type == AT_VALUE) - res = func_equals(*value, 1, &arg); - else - { - res = query_func_is_true(arg.a.invocation.func( - *value, - arg.a.invocation.argc, - arg.a.invocation.argv - ), 0, NULL); - value = NULL; - } - if (!res.val.bool_) - break; } return res; } diff --git a/libretro-db/rmsgpack.c b/libretro-db/rmsgpack.c index a1ae38da3f..0e40f43351 100644 --- a/libretro-db/rmsgpack.c +++ b/libretro-db/rmsgpack.c @@ -76,69 +76,63 @@ static const uint8_t MPF_NIL = _MPF_NIL; int rmsgpack_write_array_header(RFILE *fd, uint32_t size) { - uint16_t tmp_i16; - uint32_t tmp_i32; - static const uint8_t MPF_ARRAY32 = _MPF_ARRAY32; - if (size < 16) { size = (size | MPF_FIXARRAY); - if (filestream_write(fd, &size, sizeof(int8_t)) == -1) - return -1; - return sizeof(int8_t); + if (filestream_write(fd, &size, sizeof(int8_t)) != -1) + return sizeof(int8_t); } else if (size == (uint16_t)size) { static const uint8_t MPF_ARRAY16 = _MPF_ARRAY16; - if (filestream_write(fd, &MPF_ARRAY16, sizeof(MPF_ARRAY16)) == -1) - return -1; - tmp_i16 = swap_if_little16(size); - if (filestream_write(fd, (void *)(&tmp_i16), sizeof(uint16_t)) == -1) - return -1; - return sizeof(int8_t) + sizeof(uint16_t); + if (filestream_write(fd, &MPF_ARRAY16, sizeof(MPF_ARRAY16)) != -1) + { + uint16_t tmp_i16 = swap_if_little16(size); + if (filestream_write(fd, (void *)(&tmp_i16), sizeof(uint16_t)) != -1) + return sizeof(int8_t) + sizeof(uint16_t); + } } - - if (filestream_write(fd, &MPF_ARRAY32, sizeof(MPF_ARRAY32)) == -1) - return -1; - - tmp_i32 = swap_if_little32(size); - - if (filestream_write(fd, (void *)(&tmp_i32), sizeof(uint32_t)) == -1) - return -1; - - return sizeof(int8_t) + sizeof(uint32_t); + else + { + static const uint8_t MPF_ARRAY32 = _MPF_ARRAY32; + if (filestream_write(fd, &MPF_ARRAY32, sizeof(MPF_ARRAY32)) != -1) + { + uint32_t tmp_i32 = swap_if_little32(size); + if (filestream_write(fd, (void *)(&tmp_i32), sizeof(uint32_t)) != -1) + return sizeof(int8_t) + sizeof(uint32_t); + } + } + return -1; } int rmsgpack_write_map_header(RFILE *fd, uint32_t size) { - uint16_t tmp_i16; - uint32_t tmp_i32; - if (size < 16) { size = (size | MPF_FIXMAP); - if (filestream_write(fd, &size, sizeof(int8_t)) == -1) - return -1; - return sizeof(int8_t); + if (filestream_write(fd, &size, sizeof(int8_t)) != -1) + return sizeof(int8_t); } else if (size == (uint16_t)size) { static const uint8_t MPF_MAP16 = _MPF_MAP16; - if (filestream_write(fd, &MPF_MAP16, sizeof(MPF_MAP16)) == -1) - return -1; - tmp_i16 = swap_if_little16(size); - if (filestream_write(fd, (void *)(&tmp_i16), sizeof(uint16_t)) == -1) - return -1; - return sizeof(uint8_t) + sizeof(uint16_t); + if (filestream_write(fd, &MPF_MAP16, sizeof(MPF_MAP16)) != -1) + { + uint16_t tmp_i16 = swap_if_little16(size); + if (filestream_write(fd, (void *)(&tmp_i16), sizeof(uint16_t)) != -1) + return sizeof(uint8_t) + sizeof(uint16_t); + } } - - tmp_i32 = swap_if_little32(size); - if (filestream_write(fd, &MPF_MAP32, sizeof(MPF_MAP32)) == -1) - return -1; - if (filestream_write(fd, (void *)(&tmp_i32), sizeof(uint32_t)) == -1) - return -1; - - return sizeof(int8_t) + sizeof(uint32_t); + else + { + if (filestream_write(fd, &MPF_MAP32, sizeof(MPF_MAP32)) != -1) + { + uint32_t tmp_i32 = swap_if_little32(size); + if (filestream_write(fd, (void *)(&tmp_i32), sizeof(uint32_t)) != -1) + return sizeof(int8_t) + sizeof(uint32_t); + } + } + return -1; } int rmsgpack_write_string(RFILE *fd, const char *s, uint32_t len) diff --git a/libretro-db/rmsgpack_dom.c b/libretro-db/rmsgpack_dom.c index 258cdb9f89..7cfeac1f81 100644 --- a/libretro-db/rmsgpack_dom.c +++ b/libretro-db/rmsgpack_dom.c @@ -70,7 +70,6 @@ static int dom_read_bool(int value, void *data) struct dom_reader_state *dom_state = (struct dom_reader_state *)data; struct rmsgpack_dom_value *v = (struct rmsgpack_dom_value*)dom_reader_state_pop(dom_state); - v->type = RDT_BOOL; v->val.bool_ = value; return 0; @@ -113,7 +112,6 @@ static int dom_read_bin(void *value, uint32_t len, void *data) struct dom_reader_state *dom_state = (struct dom_reader_state *)data; struct rmsgpack_dom_value *v = (struct rmsgpack_dom_value*) dom_reader_state_pop(dom_state); - v->type = RDT_BINARY; v->val.binary.len = len; v->val.binary.buff = (char *)value; @@ -211,14 +209,14 @@ struct rmsgpack_dom_value *rmsgpack_dom_value_map_value( const struct rmsgpack_dom_value *map, const struct rmsgpack_dom_value *key) { - unsigned i; - if (map->type != RDT_MAP) - return NULL; - - for (i = 0; i < map->val.map.len; i++) + if (map->type == RDT_MAP) { - if (rmsgpack_dom_value_cmp(key, &map->val.map.items[i].key) == 0) - return &map->val.map.items[i].value; + unsigned i; + for (i = 0; i < map->val.map.len; i++) + { + if (rmsgpack_dom_value_cmp(key, &map->val.map.items[i].key) == 0) + return &map->val.map.items[i].value; + } } return NULL; } @@ -228,58 +226,64 @@ int rmsgpack_dom_value_cmp( const struct rmsgpack_dom_value *b ) { - unsigned i; - - if (a == b) - return 1; - if (a->type != b->type) - return 1; - - switch (a->type) + if ((a != b) && (a->type == b->type)) { - case RDT_NULL: - return 0; - case RDT_BOOL: - return (a->val.bool_ == b->val.bool_) ? 0 : 1; - case RDT_INT: - return (a->val.int_ == b->val.int_) ? 0 : 1; - case RDT_UINT: - return (a->val.uint_ == b->val.uint_) ? 0 : 1; - case RDT_STRING: - if (a->val.string.len == b->val.string.len) - return strncmp(a->val.string.buff, - b->val.string.buff, a->val.string.len); - break; - case RDT_BINARY: - if (a->val.binary.len == b->val.binary.len) - return memcmp(a->val.binary.buff, - b->val.binary.buff, a->val.binary.len); - break; - case RDT_MAP: - if (a->val.map.len != b->val.map.len) - return 1; - for (i = 0; i < a->val.map.len; i++) - { - int rv; - if ((rv = rmsgpack_dom_value_cmp(&a->val.map.items[i].key, - &b->val.map.items[i].key)) != 0) - return rv; - if ((rv = rmsgpack_dom_value_cmp(&a->val.map.items[i].value, - &b->val.map.items[i].value)) != 0) - return rv; - } - break; - case RDT_ARRAY: - if (a->val.array.len != b->val.array.len) - return 1; - for (i = 0; i < a->val.array.len; i++) - { - int rv; - if ((rv = rmsgpack_dom_value_cmp(&a->val.array.items[i], - &b->val.array.items[i])) != 0) - return rv; - } - break; + switch (a->type) + { + case RDT_NULL: + return 0; + case RDT_BOOL: + if (a->val.bool_ == b->val.bool_) + return 0; + break; + case RDT_INT: + if (a->val.int_ == b->val.int_) + return 0; + break; + case RDT_UINT: + if (a->val.uint_ == b->val.uint_) + return 0; + break; + case RDT_STRING: + if (a->val.string.len == b->val.string.len) + return strncmp(a->val.string.buff, + b->val.string.buff, a->val.string.len); + break; + case RDT_BINARY: + if (a->val.binary.len == b->val.binary.len) + return memcmp(a->val.binary.buff, + b->val.binary.buff, a->val.binary.len); + break; + case RDT_MAP: + if (a->val.map.len == b->val.map.len) + { + unsigned i; + for (i = 0; i < a->val.map.len; i++) + { + int rv; + if ((rv = rmsgpack_dom_value_cmp(&a->val.map.items[i].key, + &b->val.map.items[i].key)) != 0) + return rv; + if ((rv = rmsgpack_dom_value_cmp(&a->val.map.items[i].value, + &b->val.map.items[i].value)) != 0) + return rv; + } + } + break; + case RDT_ARRAY: + if (a->val.array.len == b->val.array.len) + { + unsigned i; + for (i = 0; i < a->val.array.len; i++) + { + int rv; + if ((rv = rmsgpack_dom_value_cmp(&a->val.array.items[i], + &b->val.array.items[i])) != 0) + return rv; + } + } + break; + } } return 1; @@ -401,15 +405,13 @@ static struct rmsgpack_read_callbacks dom_reader_callbacks = { int rmsgpack_dom_read(RFILE *fd, struct rmsgpack_dom_value *out) { + int rv; struct dom_reader_state s; - int rv = 0; s.i = 0; s.stack[0] = out; - rv = rmsgpack_read(fd, &dom_reader_callbacks, &s); - - if (rv < 0) + if ((rv = rmsgpack_read(fd, &dom_reader_callbacks, &s)) < 0) rmsgpack_dom_value_free(out); return rv; @@ -419,10 +421,8 @@ int rmsgpack_dom_read_into(RFILE *fd, ...) { int rv; va_list ap; - const char *key_name; struct rmsgpack_dom_value map; struct rmsgpack_dom_value key; - struct rmsgpack_dom_value *value; int64_t *int_value; uint64_t *uint_value; int *bool_value; @@ -431,64 +431,63 @@ int rmsgpack_dom_read_into(RFILE *fd, ...) va_start(ap, fd); - rv = rmsgpack_dom_read(fd, &map); - - if (rv < 0) + if ((rv = rmsgpack_dom_read(fd, &map)) < 0) { va_end(ap); return rv; } - if (map.type != RDT_MAP) - goto clean; - - for (;;) + if (map.type == RDT_MAP) { - key_name = va_arg(ap, const char *); - - if (!key_name) - goto clean; - - key.type = RDT_STRING; - key.val.string.len = (uint32_t)strlen(key_name); - key.val.string.buff = (char *) key_name; - - value = rmsgpack_dom_value_map_value(&map, &key); - - switch (value->type) + for (;;) { - case RDT_INT: - int_value = va_arg(ap, int64_t *); - *int_value = value->val.int_; - break; - case RDT_BOOL: - bool_value = va_arg(ap, int *); - *bool_value = value->val.bool_; - break; - case RDT_UINT: - uint_value = va_arg(ap, uint64_t *); - *uint_value = value->val.uint_; - break; - case RDT_BINARY: - buff_value = va_arg(ap, char *); - uint_value = va_arg(ap, uint64_t *); - *uint_value = value->val.binary.len; - min_len = (value->val.binary.len > *uint_value) ? - *uint_value : value->val.binary.len; + struct rmsgpack_dom_value *value; + const char *key_name = va_arg(ap, const char *); - memcpy(buff_value, value->val.binary.buff, (size_t)min_len); - break; - case RDT_STRING: - buff_value = va_arg(ap, char *); - uint_value = va_arg(ap, uint64_t *); - min_len = (value->val.string.len + 1 > *uint_value) ? - *uint_value : value->val.string.len + 1; - *uint_value = min_len; - - memcpy(buff_value, value->val.string.buff, (size_t)min_len); - break; - default: + if (!key_name) goto clean; + + key.type = RDT_STRING; + key.val.string.len = (uint32_t)strlen(key_name); + key.val.string.buff = (char *)key_name; + + value = rmsgpack_dom_value_map_value(&map, &key); + + switch (value->type) + { + case RDT_INT: + int_value = va_arg(ap, int64_t *); + *int_value = value->val.int_; + break; + case RDT_BOOL: + bool_value = va_arg(ap, int *); + *bool_value = value->val.bool_; + break; + case RDT_UINT: + uint_value = va_arg(ap, uint64_t *); + *uint_value = value->val.uint_; + break; + case RDT_BINARY: + buff_value = va_arg(ap, char *); + uint_value = va_arg(ap, uint64_t *); + *uint_value = value->val.binary.len; + min_len = (value->val.binary.len > *uint_value) ? + *uint_value : value->val.binary.len; + + memcpy(buff_value, value->val.binary.buff, (size_t)min_len); + break; + case RDT_STRING: + buff_value = va_arg(ap, char *); + uint_value = va_arg(ap, uint64_t *); + min_len = (value->val.string.len + 1 > *uint_value) ? + *uint_value : value->val.string.len + 1; + *uint_value = min_len; + + memcpy(buff_value, value->val.string.buff, (size_t)min_len); + break; + default: + goto clean; + } } }