mirror of
https://github.com/libretro/RetroArch
synced 2025-02-20 15:40:44 +00:00
(libretro-db) Cleanups/style nits
This commit is contained in:
libretroadmin
parent
dc35763677
commit
2d48cbaec6
@ -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);
|
||||
}
|
||||
|
||||
@ -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);
|
||||
}
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user