From 6e979579ea458b4e338a96035c69ecb1e69479b1 Mon Sep 17 00:00:00 2001 From: Max Wash Date: Sun, 19 Oct 2025 21:01:27 +0100 Subject: [PATCH] serial: update to use new object system --- serial/include/blue/serial.h | 15 ++- serial/json.c | 130 +++++++++++------------ serial/serial.c | 6 +- serial/serial.h | 5 +- serial/toml.c | 197 +++++++++++++++++------------------ 5 files changed, 169 insertions(+), 184 deletions(-) diff --git a/serial/include/blue/serial.h b/serial/include/blue/serial.h index 38587db..0d11ce0 100644 --- a/serial/include/blue/serial.h +++ b/serial/include/blue/serial.h @@ -1,12 +1,11 @@ -#ifndef BLUELIB_SERIAL_H_ -#define BLUELIB_SERIAL_H_ +#ifndef BLUE_SERIAL_H_ +#define BLUE_SERIAL_H_ #include +#include #include #include -struct b_dsref; - typedef enum b_serial_format { B_SERIAL_FORMAT_NONE = 0, B_SERIAL_FORMAT_BITCODE, @@ -25,11 +24,11 @@ BLUE_API b_status b_serial_ctx_create(b_serial_ctx **out); BLUE_API b_status b_serial_ctx_destroy(b_serial_ctx *ctx); BLUE_API b_status b_serial_ctx_serialise( - b_serial_ctx *ctx, b_serial_format fmt, struct b_dsref *src, - b_stream *dest, b_serial_flags flags); + b_serial_ctx *ctx, b_serial_format fmt, b_object *src, b_stream *dest, + b_serial_flags flags); BLUE_API b_status b_serial_ctx_deserialise( - b_serial_ctx *ctx, b_serial_format fmt, b_stream *src, - struct b_dsref **dest, b_serial_flags flags); + b_serial_ctx *ctx, b_serial_format fmt, b_stream *src, b_object **dest, + b_serial_flags flags); #endif diff --git a/serial/json.c b/serial/json.c index 061c352..9642620 100644 --- a/serial/json.c +++ b/serial/json.c @@ -40,7 +40,6 @@ #include #include #include -#include #include #include #include @@ -2933,21 +2932,21 @@ CJSON_PUBLIC(void) cJSON_free(void *object) object = NULL; } -static enum b_status b_dsref_to_cJSON(const struct b_dsref *object, cJSON **out); +static enum b_status b_object_to_cJSON(const b_object *object, cJSON **out); -static enum b_status serialise_array(const struct b_dsref *object, cJSON **out) +static enum b_status serialise_array(const b_object *object, cJSON **out) { cJSON *json_array = cJSON_CreateArray(); if (!json_array) { return B_ERR_NO_MEMORY; } - struct b_array *array = B_ARRAY(object); + b_array *array = (b_array *)object; b_array_iterator it; b_array_foreach(&it, array) { cJSON *child = NULL; - enum b_status status = b_dsref_to_cJSON(it.value, &child); + enum b_status status = b_object_to_cJSON(it.value, &child); if (!B_OK(status)) { cJSON_Delete(json_array); return status; @@ -2960,19 +2959,19 @@ static enum b_status serialise_array(const struct b_dsref *object, cJSON **out) return B_SUCCESS; } -static enum b_status serialise_dict(const struct b_dsref *object, cJSON **out) +static enum b_status serialise_dict(const b_object *object, cJSON **out) { cJSON *json_dict = cJSON_CreateObject(); if (!json_dict) { return B_ERR_NO_MEMORY; } - struct b_dict *dict = B_DICT(object); + b_dict *dict = (b_dict *)object; b_dict_iterator it; b_dict_foreach(&it, dict) { cJSON *child = NULL; - enum b_status status = b_dsref_to_cJSON(it.value, &child); + enum b_status status = b_object_to_cJSON(it.value, &child); if (!B_OK(status)) { cJSON_Delete(json_dict); return status; @@ -2985,15 +2984,15 @@ static enum b_status serialise_dict(const struct b_dsref *object, cJSON **out) return B_SUCCESS; } -static enum b_status serialise_number(const struct b_dsref *object, cJSON **out) +static enum b_status serialise_number(const b_object *object, cJSON **out) { cJSON *json_number = cJSON_CreateNumber(0); if (!json_number) { return B_ERR_NO_MEMORY; } - struct b_number *number = B_NUMBER(object); - enum b_number_type type = b_number_get_type(number); + b_number *number = (b_number *)object; + enum b_number_type type = b_number_get_number_type(number); switch (type) { case B_NUMBER_INT8: @@ -3049,9 +3048,9 @@ static enum b_status serialise_number(const struct b_dsref *object, cJSON **out) return B_SUCCESS; } -static enum b_status serialise_string(const struct b_dsref *object, cJSON **out) +static enum b_status serialise_string(const b_object *object, cJSON **out) { - struct b_string *string = B_STRING(object); + b_string *string = (b_string *)object; cJSON *json_string = cJSON_CreateStringReference(b_string_ptr(string)); if (!json_string) { return B_ERR_NO_MEMORY; @@ -3061,9 +3060,9 @@ static enum b_status serialise_string(const struct b_dsref *object, cJSON **out) return B_SUCCESS; } -static enum b_status serialise_uuid(const struct b_dsref *object, cJSON **out) +static enum b_status serialise_uuid(const b_object *object, cJSON **out) { - struct b_uuid *uuid = B_UUID(object); + b_uuid *uuid = (b_uuid *)object; char s[B_UUID_STRING_MAX]; b_uuid_to_cstr(uuid, s); @@ -3076,39 +3075,28 @@ static enum b_status serialise_uuid(const struct b_dsref *object, cJSON **out) return B_SUCCESS; } -typedef enum b_status (*object_serialise_callback)( - const struct b_dsref *, cJSON **); - -static const object_serialise_callback object_serialise[] = { - [B_DSREF_TYPE_ARRAY] = serialise_array, - [B_DSREF_TYPE_DICT] = serialise_dict, - [B_DSREF_TYPE_NUMBER] = serialise_number, - [B_DSREF_TYPE_STRING] = serialise_string, - [B_DSREF_TYPE_UUID] = serialise_uuid, -}; -static const size_t nr_object_serialise - = sizeof object_serialise / sizeof object_serialise[0]; - -static enum b_status b_dsref_to_cJSON(const struct b_dsref *object, cJSON **out) +static enum b_status b_object_to_cJSON(const b_object *object, cJSON **out) { - b_dsref_type_id type = b_typeid(object); - if (type >= nr_object_serialise) { + if (b_object_is_type(object, B_TYPE_ARRAY)) { + return serialise_array(object, out); + } else if (b_object_is_type(object, B_TYPE_DICT)) { + return serialise_dict(object, out); + } else if (b_object_is_type(object, B_TYPE_NUMBER)) { + return serialise_number(object, out); + } else if (b_object_is_type(object, B_TYPE_STRING)) { + return serialise_string(object, out); + } else if (b_object_is_type(object, B_TYPE_UUID)) { + return serialise_uuid(object, out); + } else { return B_ERR_NOT_SUPPORTED; } - - object_serialise_callback callback = object_serialise[type]; - if (!callback) { - return B_ERR_NOT_SUPPORTED; - } - - return callback(object, out); } -static enum b_status cJSON_to_b_dsref(cJSON *json, struct b_dsref **out); +static enum b_status cJSON_to_b_object(cJSON *json, b_object **out); -static enum b_status deserialise_dict(cJSON *json, struct b_dsref **out) +static enum b_status deserialise_dict(cJSON *json, b_object **out) { - struct b_dict *dict = b_dict_create(); + b_dict *dict = b_dict_create(); if (!dict) { return B_ERR_NO_MEMORY; } @@ -3117,29 +3105,29 @@ static enum b_status deserialise_dict(cJSON *json, struct b_dsref **out) enum b_status status = B_SUCCESS; while (item) { - struct b_dsref *child = NULL; - status = cJSON_to_b_dsref(item, &child); + b_object *child = NULL; + status = cJSON_to_b_object(item, &child); if (!B_OK(status)) { - b_dict_release(dict); + b_dict_unref(dict); dict = NULL; break; } if (child) { b_dict_put(dict, item->string, child); - b_release(child); + b_object_unref(child); } item = item->next; } - *out = B_DSREF(dict); + *out = (dict); return B_SUCCESS; } -static enum b_status deserialise_array(cJSON *json, struct b_dsref **out) +static enum b_status deserialise_array(cJSON *json, b_object **out) { - struct b_array *array = b_array_create(); + b_array *array = b_array_create(); if (!array) { return B_ERR_NO_MEMORY; } @@ -3148,40 +3136,40 @@ static enum b_status deserialise_array(cJSON *json, struct b_dsref **out) enum b_status status = B_SUCCESS; while (item) { - struct b_dsref *child = NULL; - status = cJSON_to_b_dsref(item, &child); + b_object *child = NULL; + status = cJSON_to_b_object(item, &child); if (!B_OK(status)) { - b_array_release(array); + b_array_unref(array); array = NULL; break; } if (child) { b_array_append(array, child); - b_release(child); + b_object_unref(child); } item = item->next; } - *out = B_DSREF(array); + *out = (array); return B_SUCCESS; } -static enum b_status deserialise_string(cJSON *json, struct b_dsref **out) +static enum b_status deserialise_string(cJSON *json, b_object **out) { - struct b_string *string = b_string_create_from_cstr(json->valuestring); + b_string *string = b_string_create_from_cstr(json->valuestring); if (!string) { return B_ERR_NO_MEMORY; } - *out = B_DSREF(string); + *out = (string); return B_SUCCESS; } -static enum b_status deserialise_number(cJSON *json, struct b_dsref **out) +static enum b_status deserialise_number(cJSON *json, b_object **out) { - struct b_number *number = NULL; + b_number *number = NULL; if ((double)json->valueint == json->valuedouble) { number = B_INT(json->valueint); @@ -3193,13 +3181,13 @@ static enum b_status deserialise_number(cJSON *json, struct b_dsref **out) return B_ERR_NO_MEMORY; } - *out = B_DSREF(number); + *out = (number); return B_SUCCESS; } -static enum b_status deserialise_bool(cJSON *json, struct b_dsref **out) +static enum b_status deserialise_bool(cJSON *json, b_object **out) { - struct b_number *number = NULL; + b_number *number = NULL; if (json->type == cJSON_True) { number = B_INT(1); @@ -3211,11 +3199,11 @@ static enum b_status deserialise_bool(cJSON *json, struct b_dsref **out) return B_ERR_NO_MEMORY; } - *out = B_DSREF(number); + *out = (number); return B_SUCCESS; } -static enum b_status cJSON_to_b_dsref(cJSON *json, struct b_dsref **out) +static enum b_status cJSON_to_b_object(cJSON *json, b_object **out) { switch (json->type) { case cJSON_True: @@ -3238,11 +3226,11 @@ static enum b_status cJSON_to_b_dsref(cJSON *json, struct b_dsref **out) } static enum b_status json_serialise( - struct b_serial_ctx *ctx, struct b_dsref *src, struct b_stream *dest, + struct b_serial_ctx *ctx, b_object *src, struct b_stream *dest, enum b_serial_flags flags) { cJSON *json; - enum b_status status = b_dsref_to_cJSON(src, &json); + enum b_status status = b_object_to_cJSON(src, &json); if (!B_OK(status)) { return status; @@ -3269,14 +3257,14 @@ static enum b_status json_serialise( } static enum b_status json_deserialise( - struct b_serial_ctx *ctx, struct b_stream *src, struct b_dsref **dest, + struct b_serial_ctx *ctx, struct b_stream *src, b_object **dest, enum b_serial_flags flags) { - struct b_string *json_string = b_string_create(); + b_string *json_string = b_string_create(); struct b_stream *json_stream = NULL; enum b_status status = b_string_open_stream(json_string, &json_stream); if (!B_OK(status)) { - b_string_release(json_string); + b_string_unref(json_string); return status; } @@ -3284,17 +3272,17 @@ static enum b_status json_deserialise( src, json_stream, ctx->ctx_pipeline, NULL); b_stream_close(json_stream); if (!B_OK(status)) { - b_string_release(json_string); + b_string_unref(json_string); return status; } cJSON *json = cJSON_Parse(b_string_ptr(json_string)); - b_string_release(json_string); + b_string_unref(json_string); if (!json) { return B_ERR_BAD_FORMAT; } - status = cJSON_to_b_dsref(json, dest); + status = cJSON_to_b_object(json, dest); cJSON_Delete(json); diff --git a/serial/serial.c b/serial/serial.c index caa92ee..ced1fb4 100644 --- a/serial/serial.c +++ b/serial/serial.c @@ -52,8 +52,8 @@ static const struct b_serial_format_ops *get_formatter(enum b_serial_format fmt) } enum b_status b_serial_ctx_serialise( - struct b_serial_ctx *ctx, enum b_serial_format fmt, - struct b_dsref *src, struct b_stream *dest, enum b_serial_flags flags) + struct b_serial_ctx *ctx, enum b_serial_format fmt, b_object *src, + struct b_stream *dest, enum b_serial_flags flags) { const struct b_serial_format_ops *ops = get_formatter(fmt); if (!ops) { @@ -69,7 +69,7 @@ enum b_status b_serial_ctx_serialise( enum b_status b_serial_ctx_deserialise( struct b_serial_ctx *ctx, enum b_serial_format fmt, - struct b_stream *src, struct b_dsref **dest, enum b_serial_flags flags) + struct b_stream *src, b_object **dest, enum b_serial_flags flags) { const struct b_serial_format_ops *ops = get_formatter(fmt); if (!ops) { diff --git a/serial/serial.h b/serial/serial.h index 309bc39..84f69ff 100644 --- a/serial/serial.h +++ b/serial/serial.h @@ -1,6 +1,7 @@ #ifndef _SERIAL_SERIAL_H_ #define _SERIAL_SERIAL_H_ +#include #include #include @@ -10,10 +11,10 @@ struct b_serial_ctx { struct b_serial_format_ops { enum b_status (*fmt_serialise)( - struct b_serial_ctx *, struct b_dsref *, struct b_stream *, + struct b_serial_ctx *, b_object *, struct b_stream *, enum b_serial_flags); enum b_status (*fmt_deserialise)( - struct b_serial_ctx *, struct b_stream *, struct b_dsref **, + struct b_serial_ctx *, struct b_stream *, b_object **, enum b_serial_flags); }; diff --git a/serial/toml.c b/serial/toml.c index ec9ff32..f67e805 100644 --- a/serial/toml.c +++ b/serial/toml.c @@ -119,7 +119,7 @@ struct ctx { }; static void ctx_set_object_flags( - struct ctx *ctx, struct b_dsref *obj, enum object_flags flags) + struct ctx *ctx, b_object *obj, enum object_flags flags) { if (!obj) { return; @@ -127,7 +127,7 @@ static void ctx_set_object_flags( b_hashmap_key key = { .key_data = obj, - .key_size = sizeof(struct b_dsref *), + .key_size = sizeof(b_object *), .key_flags = B_HASHMAP_KEY_F_INTVALUE, }; @@ -150,7 +150,7 @@ static void ctx_set_object_flags( } static void ctx_clear_object_flags( - struct ctx *ctx, struct b_dsref *obj, enum object_flags mask) + struct ctx *ctx, b_object *obj, enum object_flags mask) { if (!obj) { return; @@ -158,7 +158,7 @@ static void ctx_clear_object_flags( b_hashmap_key key = { .key_data = obj, - .key_size = sizeof(struct b_dsref *), + .key_size = sizeof(b_object *), .key_flags = B_HASHMAP_KEY_F_INTVALUE, }; @@ -180,7 +180,7 @@ static void ctx_clear_object_flags( b_hashmap_put(ctx->ctx_objects_flags, &key, &value); } -static enum object_flags ctx_get_object_flags(struct ctx *ctx, struct b_dsref *obj) +static enum object_flags ctx_get_object_flags(struct ctx *ctx, b_object *obj) { if (!obj) { return 0; @@ -188,7 +188,7 @@ static enum object_flags ctx_get_object_flags(struct ctx *ctx, struct b_dsref *o b_hashmap_key key = { .key_data = obj, - .key_size = sizeof(struct b_dsref *), + .key_size = sizeof(b_object *), .key_flags = B_HASHMAP_KEY_F_INTVALUE, }; @@ -231,7 +231,7 @@ static enum b_status refill_linebuf(struct ctx *ctx) return B_SUCCESS; } -static struct b_string *get_wordbuf(struct ctx *ctx) +static b_string *get_wordbuf(struct ctx *ctx) { b_string_clear(ctx->ctx_wordbuf); return ctx->ctx_wordbuf; @@ -394,7 +394,7 @@ static void discard_token(struct ctx *ctx) free(tok); } -static bool try_convert_word_to_timestamp(struct ctx *ctx, struct b_string *token_str) +static bool try_convert_word_to_timestamp(struct ctx *ctx, b_string *token_str) { b_datetime *dt = b_datetime_parse( B_DATETIME_FORMAT_RFC3339, b_string_ptr(token_str)); @@ -410,7 +410,7 @@ static bool try_convert_word_to_timestamp(struct ctx *ctx, struct b_string *toke } #if 0 -static bool try_convert_word_to_timestamp(struct ctx *ctx, struct b_string *token_str) +static bool try_convert_word_to_timestamp(struct ctx *ctx, b_string *token_str) { const char *s = b_string_ptr(token_str); size_t len = b_string_get_size(token_str, B_STRLEN_NORMAL); @@ -614,10 +614,10 @@ static bool has_trailing_zero(const char *s) return false; } -static bool try_convert_word_to_number(struct ctx *ctx, struct b_string *token_str) +static bool try_convert_word_to_number(struct ctx *ctx, b_string *token_str) { size_t len = b_string_get_size(token_str, B_STRLEN_NORMAL); - struct b_string *str = b_string_duplicate(token_str); + b_string *str = b_string_duplicate(token_str); struct token *tok = NULL; const char *s = b_string_ptr(str); @@ -817,7 +817,7 @@ static bool try_convert_word_to_number(struct ctx *ctx, struct b_string *token_s return true; } -static bool try_convert_word_to_bool(struct ctx *ctx, struct b_string *token_str) +static bool try_convert_word_to_bool(struct ctx *ctx, b_string *token_str) { const char *s = b_string_ptr(token_str); struct token *tok = NULL; @@ -837,7 +837,7 @@ static bool try_convert_word_to_bool(struct ctx *ctx, struct b_string *token_str return true; } -static void split_word(struct ctx *ctx, struct b_string *wordbuf) +static void split_word(struct ctx *ctx, b_string *wordbuf) { #if 0 long len = b_string_get_size(wordbuf, B_STRLEN_NORMAL); @@ -924,7 +924,7 @@ static void split_word(struct ctx *ctx, struct b_string *wordbuf) static void read_number(struct ctx *ctx) { b_wchar c = 0; - struct b_string *wordbuf = get_wordbuf(ctx); + b_string *wordbuf = get_wordbuf(ctx); while (1) { c = peek_char(ctx); @@ -954,7 +954,7 @@ static void read_number(struct ctx *ctx) static void read_word(struct ctx *ctx) { b_wchar c = 0; - struct b_string *wordbuf = get_wordbuf(ctx); + b_string *wordbuf = get_wordbuf(ctx); while (1) { c = peek_char(ctx); @@ -1084,7 +1084,7 @@ static void read_string(struct ctx *ctx, bool squote) bool multiline = false; struct token *tok = enqueue_token(ctx, TOK_STRING); - struct b_string *str = get_wordbuf(ctx); + b_string *str = get_wordbuf(ctx); b_wchar c = peek_char(ctx); if (c == term) { @@ -1513,17 +1513,17 @@ static void ctx_cleanup(struct ctx *ctx) } if (ctx->ctx_linebuf) { - b_string_release(ctx->ctx_linebuf); + b_string_unref(ctx->ctx_linebuf); ctx->ctx_linebuf = NULL; } if (ctx->ctx_wordbuf) { - b_string_release(ctx->ctx_wordbuf); + b_string_unref(ctx->ctx_wordbuf); ctx->ctx_wordbuf = NULL; } if (ctx->ctx_objects_flags) { - b_hashmap_release(ctx->ctx_objects_flags); + b_hashmap_unref(ctx->ctx_objects_flags); ctx->ctx_objects_flags = NULL; } } @@ -1543,7 +1543,7 @@ static enum b_status ctx_init(struct ctx *ctx) } static enum b_status toml_serialise( - struct b_serial_ctx *serial, struct b_dsref *src, struct b_stream *dest, + struct b_serial_ctx *serial, b_object *src, struct b_stream *dest, enum b_serial_flags flags) { return B_SUCCESS; @@ -1636,35 +1636,35 @@ static void print_token(struct token *tok) } } -static enum b_status parse_value(struct ctx *ctx, struct b_dsref **result); -static enum b_status parse_key_value_pair(struct ctx *ctx, struct b_dict *container); +static enum b_status parse_value(struct ctx *ctx, b_object **result); +static enum b_status parse_key_value_pair(struct ctx *ctx, b_dict *container); -static enum b_status parse_timestamp(struct ctx *ctx, struct b_dsref **result) +static enum b_status parse_timestamp(struct ctx *ctx, b_object **result) { struct token *tok = peek_token(ctx); - struct b_datetime *dt = tok->tok_value.time; + b_datetime *dt = tok->tok_value.time; tok->tok_value.time = NULL; - *result = B_DSREF(dt); + *result = (dt); return B_SUCCESS; } -static enum b_status parse_string(struct ctx *ctx, struct b_dsref **result) +static enum b_status parse_string(struct ctx *ctx, b_object **result) { struct token *tok = peek_token(ctx); - struct b_string *str = b_string_duplicate(tok->tok_str); + b_string *str = b_string_duplicate(tok->tok_str); if (!str) { return B_ERR_NO_MEMORY; } - *result = B_DSREF(str); + *result = (str); return B_SUCCESS; } -static enum b_status parse_int(struct ctx *ctx, struct b_dsref **result) +static enum b_status parse_int(struct ctx *ctx, b_object **result) { struct token *tok = peek_token(ctx); - struct b_number *val = B_LONGLONG(tok->tok_value.i.v); + b_number *val = B_LONGLONG(tok->tok_value.i.v); if (!val) { return B_ERR_NO_MEMORY; } @@ -1683,14 +1683,14 @@ static enum b_status parse_int(struct ctx *ctx, struct b_dsref **result) } } - *result = B_DSREF(val); + *result = (val); return B_SUCCESS; } -static enum b_status parse_float(struct ctx *ctx, struct b_dsref **result) +static enum b_status parse_float(struct ctx *ctx, b_object **result) { struct token *tok = peek_token(ctx); - struct b_number *val = B_DOUBLE(tok->tok_value.f.v); + b_number *val = B_DOUBLE(tok->tok_value.f.v); if (!val) { return B_ERR_NO_MEMORY; } @@ -1709,53 +1709,53 @@ static enum b_status parse_float(struct ctx *ctx, struct b_dsref **result) } } - *result = B_DSREF(val); + *result = (val); return B_SUCCESS; } -static enum b_status parse_bool(struct ctx *ctx, struct b_dsref **result) +static enum b_status parse_bool(struct ctx *ctx, b_object **result) { struct token *tok = peek_token(ctx); - struct b_number *val = B_INT8(tok->tok_value.b); + b_number *val = B_INT8(tok->tok_value.b); if (!val) { return B_ERR_NO_MEMORY; } - *result = B_DSREF(val); + *result = (val); return B_SUCCESS; } -static enum b_status parse_table_inline(struct ctx *ctx, struct b_dsref **result) +static enum b_status parse_table_inline(struct ctx *ctx, b_object **result) { DISABLE_EXTENDED_LEXING(ctx); advance_token(ctx); - struct b_dict *table = b_dict_create(); + b_dict *table = b_dict_create(); if (!table) { return B_ERR_NO_MEMORY; } struct token *tok = peek_token(ctx); if (tok && tok->tok_type == TOK_RIGHT_BRACE) { - *result = B_DSREF(table); + *result = (table); return B_SUCCESS; } bool done = false; while (!done) { - struct b_dsref *value; + b_object *value; enum b_status status = parse_key_value_pair(ctx, table); if (!B_OK(status)) { - b_dict_release(table); + b_dict_unref(table); return status; } tok = peek_token(ctx); if (!tok) { - b_dict_release(table); + b_dict_unref(table); return status; } @@ -1767,12 +1767,12 @@ static enum b_status parse_table_inline(struct ctx *ctx, struct b_dsref **result advance_token(ctx); break; default: - b_dict_release(table); + b_dict_unref(table); return B_ERR_BAD_FORMAT; } } - *result = B_DSREF(table); + *result = (table); return B_SUCCESS; } @@ -1786,21 +1786,21 @@ static void skip_newlines(struct ctx *ctx) } } -static enum b_status parse_array_inline(struct ctx *ctx, struct b_dsref **result) +static enum b_status parse_array_inline(struct ctx *ctx, b_object **result) { bool done = false; ENABLE_EXTENDED_LEXING(ctx); advance_token(ctx); - struct b_array *array = b_array_create(); + b_array *array = b_array_create(); if (!array) { return B_ERR_NO_MEMORY; } struct token *tok = peek_token(ctx); if (!tok) { - b_array_release(array); + b_array_unref(array); return B_ERR_BAD_FORMAT; } @@ -1814,7 +1814,7 @@ static enum b_status parse_array_inline(struct ctx *ctx, struct b_dsref **result tok = peek_token(ctx); if (!tok) { - b_array_release(array); + b_array_unref(array); return B_ERR_BAD_FORMAT; } @@ -1823,10 +1823,10 @@ static enum b_status parse_array_inline(struct ctx *ctx, struct b_dsref **result break; } - struct b_dsref *value; + b_object *value; enum b_status status = parse_value(ctx, &value); if (!B_OK(status)) { - b_array_release(array); + b_array_unref(array); return status; } @@ -1844,7 +1844,7 @@ static enum b_status parse_array_inline(struct ctx *ctx, struct b_dsref **result } if (!tok || tok->tok_type != TOK_COMMA) { - b_array_release(array); + b_array_unref(array); return B_ERR_BAD_FORMAT; } @@ -1853,11 +1853,11 @@ static enum b_status parse_array_inline(struct ctx *ctx, struct b_dsref **result } DISABLE_EXTENDED_LEXING(ctx); - *result = B_DSREF(array); + *result = (array); return B_SUCCESS; } -static enum b_status parse_value(struct ctx *ctx, struct b_dsref **result) +static enum b_status parse_value(struct ctx *ctx, b_object **result) { struct token *tok = peek_token(ctx); @@ -1885,7 +1885,7 @@ static enum b_status parse_value(struct ctx *ctx, struct b_dsref **result) } } -static enum b_status parse_key_value_pair(struct ctx *ctx, struct b_dict *container) +static enum b_status parse_key_value_pair(struct ctx *ctx, b_dict *container) { struct token *tok = peek_token(ctx); if (!IS_VALID_KEY_COMPONENT(tok)) { @@ -1904,11 +1904,11 @@ static enum b_status parse_key_value_pair(struct ctx *ctx, struct b_dict *contai } while (tok && tok->tok_type == TOK_DOT) { - struct b_dsref *sub_dict = b_dict_at_sk(container, key); + b_object *sub_dict = b_dict_at_sk(container, key); if (!sub_dict) { - sub_dict = B_DSREF(b_dict_create()); + sub_dict = (b_dict_create()); b_dict_put_sk(container, key, B_RV(sub_dict)); - } else if (sub_dict && !B_DSREF_IS(sub_dict, DICT)) { + } else if (sub_dict && !b_object_is_type(sub_dict, B_TYPE_DICT)) { free(key); return B_ERR_BAD_FORMAT; } @@ -1930,8 +1930,8 @@ static enum b_status parse_key_value_pair(struct ctx *ctx, struct b_dict *contai return B_ERR_BAD_FORMAT; } - container = B_DICT(sub_dict); - b_string_release(key); + container = sub_dict; + b_string_unref(key); key = b_string_duplicate(tok->tok_str); if (!key) { return B_ERR_NO_MEMORY; @@ -1956,7 +1956,7 @@ static enum b_status parse_key_value_pair(struct ctx *ctx, struct b_dict *contai ENABLE_EXTENDED_LEXING(ctx); advance_token(ctx); - struct b_dsref *value = NULL; + b_object *value = NULL; enum b_status status = parse_value(ctx, &value); DISABLE_EXTENDED_LEXING(ctx); @@ -1972,7 +1972,8 @@ static enum b_status parse_key_value_pair(struct ctx *ctx, struct b_dict *contai b_dict_put_sk(container, key, B_RV(value)); - if (B_DSREF_IS(value, DICT) || B_DSREF_IS(value, ARRAY)) { + if (b_object_is_type(value, B_TYPE_DICT) + || b_object_is_type(value, B_TYPE_ARRAY)) { ctx_set_object_flags(ctx, value, OBJECT_KV_END_DEFINED); } @@ -1980,7 +1981,7 @@ static enum b_status parse_key_value_pair(struct ctx *ctx, struct b_dict *contai } static enum b_status parse_table_header( - struct ctx *ctx, struct b_dict *container, struct b_dict **new_container) + struct ctx *ctx, b_dict *container, b_dict **new_container) { advance_token(ctx); struct token *tok = peek_token(ctx); @@ -2000,17 +2001,15 @@ static enum b_status parse_table_header( } while (tok && tok->tok_type == TOK_DOT) { - struct b_dsref *sub_dict = b_dict_at_sk(container, key); + b_object *sub_dict = b_dict_at_sk(container, key); enum object_flags flags = ctx_get_object_flags(ctx, sub_dict); if (!sub_dict) { - sub_dict = B_DSREF(b_dict_create()); + sub_dict = (b_dict_create()); b_dict_put_sk(container, key, B_RV(sub_dict)); - } else if (B_DSREF_IS(sub_dict, ARRAY)) { + } else if (b_object_is_type(sub_dict, B_TYPE_ARRAY)) { - sub_dict = b_array_at( - B_ARRAY(sub_dict), - b_array_size(B_ARRAY(sub_dict)) - 1); - } else if (!B_DSREF_IS(sub_dict, DICT)) { + sub_dict = b_array_at(sub_dict, b_array_size(sub_dict) - 1); + } else if (!b_object_is_type(sub_dict, B_TYPE_DICT)) { return B_ERR_BAD_FORMAT; } @@ -2026,8 +2025,8 @@ static enum b_status parse_table_header( ctx_set_object_flags(ctx, sub_dict, OBJECT_HEADER_MID_DEFINED); - container = B_DICT(sub_dict); - b_string_release(key); + container = sub_dict; + b_string_unref(key); key = b_string_duplicate(tok->tok_str); if (!key) { return B_ERR_NO_MEMORY; @@ -2041,7 +2040,7 @@ static enum b_status parse_table_header( return B_ERR_BAD_FORMAT; } - struct b_dict *new_table = B_DICT(b_dict_at_sk(container, key)); + b_dict *new_table = b_dict_at_sk(container, key); if (!new_table) { new_table = b_dict_create(); @@ -2054,19 +2053,19 @@ static enum b_status parse_table_header( b_dict_put_sk(container, key, B_RV(new_table)); } - if (!B_DSREF_IS(B_DSREF(new_table), DICT)) { + if (!b_object_is_type((new_table), B_TYPE_DICT)) { return B_ERR_BAD_FORMAT; } - enum object_flags flags = ctx_get_object_flags(ctx, B_DSREF(new_table)); + enum object_flags flags = ctx_get_object_flags(ctx, (new_table)); if (flags & (OBJECT_HEADER_END_DEFINED | OBJECT_KV_MID_DEFINED | OBJECT_KV_END_DEFINED)) { return B_ERR_BAD_FORMAT; } - ctx_set_object_flags(ctx, B_DSREF(new_table), OBJECT_HEADER_END_DEFINED); - b_string_release(key); + ctx_set_object_flags(ctx, (new_table), OBJECT_HEADER_END_DEFINED); + b_string_unref(key); advance_token(ctx); *new_container = new_table; @@ -2074,7 +2073,7 @@ static enum b_status parse_table_header( } static enum b_status parse_array_header( - struct ctx *ctx, struct b_dict *container, struct b_dict **new_container) + struct ctx *ctx, b_dict *container, b_dict **new_container) { advance_token(ctx); struct token *tok = peek_token(ctx); @@ -2094,15 +2093,13 @@ static enum b_status parse_array_header( } while (tok && tok->tok_type == TOK_DOT) { - struct b_dsref *sub_dict = b_dict_at_sk(container, key); + b_object *sub_dict = b_dict_at_sk(container, key); if (!sub_dict) { - sub_dict = B_DSREF(b_dict_create()); + sub_dict = (b_dict_create()); b_dict_put_sk(container, key, B_RV(sub_dict)); - } else if (B_DSREF_IS(sub_dict, ARRAY)) { - sub_dict = b_array_at( - B_ARRAY(sub_dict), - b_array_size(B_ARRAY(sub_dict)) - 1); - } else if (!B_DSREF_IS(sub_dict, DICT)) { + } else if (b_object_is_type(sub_dict, B_TYPE_ARRAY)) { + sub_dict = b_array_at(sub_dict, b_array_size(sub_dict) - 1); + } else if (!b_object_is_type(sub_dict, B_TYPE_DICT)) { return B_ERR_BAD_FORMAT; } @@ -2112,8 +2109,8 @@ static enum b_status parse_array_header( return B_ERR_BAD_FORMAT; } - container = B_DICT(sub_dict); - b_string_release(key); + container = sub_dict; + b_string_unref(key); key = b_string_duplicate(tok->tok_str); if (!key) { return B_ERR_NO_MEMORY; @@ -2127,21 +2124,21 @@ static enum b_status parse_array_header( return B_ERR_BAD_FORMAT; } - struct b_array *array = B_ARRAY(b_dict_get_sk(container, key)); + b_array *array = b_dict_get_sk(container, key); if (!array) { array = b_array_create(); b_dict_put_sk(container, key, B_RV(array)); - } else if (!B_DSREF_IS(array, ARRAY)) { + } else if (!b_object_is_type(array, B_TYPE_ARRAY)) { return B_ERR_BAD_FORMAT; } free(key); - enum object_flags flags = ctx_get_object_flags(ctx, B_DSREF(array)); + enum object_flags flags = ctx_get_object_flags(ctx, (array)); if (flags & OBJECT_KV_END_DEFINED) { return B_ERR_NO_MEMORY; } - struct b_dict *new_table = b_dict_create(); + b_dict *new_table = b_dict_create(); if (!new_table) { return B_ERR_NO_MEMORY; } @@ -2153,11 +2150,11 @@ static enum b_status parse_array_header( return B_SUCCESS; } -static enum b_status parse_root(struct ctx *ctx, struct b_dict **result) +static enum b_status parse_root(struct ctx *ctx, b_dict **result) { enum b_status status = B_SUCCESS; - struct b_dict *root = b_dict_create(); - struct b_dict *current = root; + b_dict *root = b_dict_create(); + b_dict *current = root; while (!(ctx->ctx_flags & CTX_EOF) && B_OK(status)) { struct token *tok = peek_token(ctx); @@ -2215,7 +2212,7 @@ static enum b_status parse_root(struct ctx *ctx, struct b_dict **result) } if (!B_OK(status)) { - b_dict_release(root); + b_dict_unref(root); root = NULL; } @@ -2224,8 +2221,8 @@ static enum b_status parse_root(struct ctx *ctx, struct b_dict **result) } static enum b_status toml_deserialise( - struct b_serial_ctx *serial, struct b_stream *src, - struct b_dsref **dest, enum b_serial_flags flags) + struct b_serial_ctx *serial, struct b_stream *src, b_object **dest, + enum b_serial_flags flags) { struct ctx ctx = {0}; enum b_status status = ctx_init(&ctx); @@ -2244,17 +2241,17 @@ static enum b_status toml_deserialise( } if (ctx.ctx_flags & CTX_EOF) { - *dest = B_DSREF(b_dict_create()); + *dest = (b_dict_create()); return B_SUCCESS; } - struct b_dict *result = NULL; + b_dict *result = NULL; status = parse_root(&ctx, &result); if (!B_OK(status)) { return status; } - *dest = B_DSREF(result); + *dest = (result); #if 0 ctx.ctx_flags = CTX_ENABLE_NUMBERS | CTX_ENABLE_TIMESTAMPS | CTX_ENABLE_BOOLS;