serialize_flag.c File Reference

#include <rz_util/rz_serialize.h>
#include <rz_flag.h>

Go to the source code of this file.

Classes
struct	FlagLoadCtx

Enumerations
enum	FlagField {   FLAG_FIELD_REALNAME , FLAG_FIELD_DEMANGLED , FLAG_FIELD_OFFSET , FLAG_FIELD_SIZE ,   FLAG_FIELD_SPACE , FLAG_FIELD_COLOR , FLAG_FIELD_COMMENT , FLAG_FIELD_ALIAS }

Functions
RZ_API void	rz_serialize_flag_zones_save (RZ_NONNULL Sdb *db, RZ_NONNULL RzList *zones)
static bool	zone_load_cb (void *user, const char *k, const char *v)
RZ_API bool	rz_serialize_flag_zones_load (RZ_NONNULL Sdb *db, RZ_NONNULL RzList *zones, RZ_NULLABLE RzSerializeResultInfo *res)
static bool	flag_save_cb (RzFlagItem *flag, void *user)
RZ_API void	rz_serialize_flag_save (RZ_NONNULL Sdb *db, RZ_NONNULL RzFlag *flag)
static bool	flag_load_cb (void *user, const char *k, const char *v)
static bool	load_flags (RZ_NONNULL Sdb *flags_db, RZ_NONNULL RzFlag *flag)
RZ_API bool	rz_serialize_flag_load (RZ_NONNULL Sdb *db, RZ_NONNULL RzFlag *flag, RZ_NULLABLE RzSerializeResultInfo *res)

Enumeration Type Documentation

FlagField

enum FlagField

Enumerator
FLAG_FIELD_REALNAME
FLAG_FIELD_DEMANGLED
FLAG_FIELD_OFFSET
FLAG_FIELD_SIZE
FLAG_FIELD_SPACE
FLAG_FIELD_COLOR
FLAG_FIELD_COMMENT
FLAG_FIELD_ALIAS

Definition at line 136 of file serialize_flag.c.

             {
    FLAG_FIELD_REALNAME,
    FLAG_FIELD_DEMANGLED,
    FLAG_FIELD_OFFSET,
    FLAG_FIELD_SIZE,
    FLAG_FIELD_SPACE,
    FLAG_FIELD_COLOR,
    FLAG_FIELD_COMMENT,
    FLAG_FIELD_ALIAS
} FlagField;

Function Documentation

flag_load_cb()

static bool flag_load_cb ( void *  user, const char *  k, const char *  v  )

static

Definition at line 152 of file serialize_flag.c.

                                                                   {
    FlagLoadCtx *ctx = user;
 
    char *json_str = strdup(v);
    if (!json_str) {
        return true;
    }
    RzJson *json = rz_json_parse(json_str);
    if (!json || json->type != RZ_JSON_OBJECT) {
        free(json_str);
        return false;
    }
 
    RzFlagItem proto = { 0 };
    bool offset_set = false;
    bool size_set = false;
 
    RZ_KEY_PARSER_JSON(ctx->parser, json, child, {
        case FLAG_FIELD_REALNAME:
            if (child->type != RZ_JSON_STRING) {
                break;
            }
            proto.realname = (char *)child->str_value;
            break;
        case FLAG_FIELD_DEMANGLED:
            if (child->type != RZ_JSON_BOOLEAN) {
                break;
            }
            proto.demangled = child->num.u_value != 0;
            break;
        case FLAG_FIELD_OFFSET:
            if (child->type != RZ_JSON_INTEGER) {
                break;
            }
            proto.offset = child->num.u_value;
            offset_set = true;
            break;
        case FLAG_FIELD_SIZE:
            if (child->type != RZ_JSON_INTEGER) {
                break;
            }
            proto.size = child->num.u_value;
            size_set = true;
            break;
        case FLAG_FIELD_SPACE:
            if (child->type != RZ_JSON_STRING) {
                break;
            }
            proto.space = rz_flag_space_get(ctx->flag, child->str_value);
            break;
        case FLAG_FIELD_COLOR:
            if (child->type != RZ_JSON_STRING) {
                break;
            }
            proto.color = (char *)child->str_value;
            break;
        case FLAG_FIELD_COMMENT:
            if (child->type != RZ_JSON_STRING) {
                break;
            }
            proto.comment = (char *)child->str_value;
            break;
        case FLAG_FIELD_ALIAS:
            if (child->type != RZ_JSON_STRING) {
                break;
            }
            proto.alias = (char *)child->str_value;
            break;
        default:
            break;
    });
 
    bool res = true;
    if (!offset_set || !size_set) {
        res = false;
        goto beach;
    }
 
    RzFlagItem *item = rz_flag_set(ctx->flag, k, proto.offset - ctx->flag->base, proto.size);
    if (proto.realname) {
        rz_flag_item_set_realname(item, proto.realname);
    }
    item->demangled = proto.demangled;
    item->space = proto.space;
    if (proto.color) {
        rz_flag_item_set_color(item, proto.color);
    }
    if (proto.comment) {
        rz_flag_item_set_comment(item, proto.comment);
    }
    if (proto.alias) {
        rz_flag_item_set_alias(item, proto.alias);
    }
 
beach:
    rz_json_free(json);
    free(json_str);
    return res;
}

References rz_flag_item_t::alias, rz_flag_item_t::color, rz_flag_item_t::comment, rz_flag_item_t::demangled, FLAG_FIELD_ALIAS, FLAG_FIELD_COLOR, FLAG_FIELD_COMMENT, FLAG_FIELD_DEMANGLED, FLAG_FIELD_OFFSET, FLAG_FIELD_SIZE, FLAG_FIELD_SPACE, free(), if(), rz_flag_item_t::offset, rz_flag_item_t::realname, RZ_JSON_BOOLEAN, RZ_JSON_INTEGER, RZ_JSON_OBJECT, rz_json_parse(), RZ_JSON_STRING, RZ_KEY_PARSER_JSON, rz_flag_item_t::size, rz_flag_item_t::space, strdup(), rz_json_t::type, and v.

Referenced by load_flags().

flag_save_cb()

static bool flag_save_cb ( RzFlagItem *  flag, void *  user  )

static

Definition at line 92 of file serialize_flag.c.

                                                       {
    Sdb *db = user;
    PJ *j = pj_new();
    if (!j) {
        return false;
    }
    pj_o(j);
    if (flag->realname) {
        pj_ks(j, "realname", flag->realname);
    }
    pj_kb(j, "demangled", flag->demangled);
    pj_kn(j, "offset", flag->offset);
    pj_kn(j, "size", flag->size);
    if (flag->space) {
        pj_ks(j, "space", flag->space->name);
    }
    if (flag->color) {
        pj_ks(j, "color", flag->color);
    }
    if (flag->comment) {
        pj_ks(j, "comment", flag->comment);
    }
    if (flag->alias) {
        pj_ks(j, "alias", flag->alias);
    }
    pj_end(j);
    sdb_set(db, flag->name, pj_string(j), 0);
    pj_free(j);
    return true;
}

References rz_flag_item_t::alias, rz_flag_item_t::color, rz_flag_item_t::comment, rz_flag_item_t::demangled, rz_flag_item_t::name, rz_space_t::name, rz_flag_item_t::offset, pj_end(), pj_free(), pj_kb(), pj_kn(), pj_ks(), pj_new(), pj_o(), pj_string(), rz_flag_item_t::realname, sdb_set(), rz_flag_item_t::size, and rz_flag_item_t::space.

Referenced by rz_serialize_flag_save().

load_flags()

static bool load_flags ( RZ_NONNULL Sdb *  flags_db, RZ_NONNULL RzFlag *  flag  )

static

Definition at line 252 of file serialize_flag.c.

                                                                          {
    FlagLoadCtx ctx = { flag, rz_key_parser_new() };
    if (!ctx.parser) {
        return false;
    }
    rz_key_parser_add(ctx.parser, "realname", FLAG_FIELD_REALNAME);
    rz_key_parser_add(ctx.parser, "demangled", FLAG_FIELD_DEMANGLED);
    rz_key_parser_add(ctx.parser, "offset", FLAG_FIELD_OFFSET);
    rz_key_parser_add(ctx.parser, "size", FLAG_FIELD_SIZE);
    rz_key_parser_add(ctx.parser, "space", FLAG_FIELD_SPACE);
    rz_key_parser_add(ctx.parser, "color", FLAG_FIELD_COLOR);
    rz_key_parser_add(ctx.parser, "comment", FLAG_FIELD_COMMENT);
    rz_key_parser_add(ctx.parser, "alias", FLAG_FIELD_ALIAS);
    bool r = sdb_foreach(flags_db, flag_load_cb, &ctx);
    rz_key_parser_free(ctx.parser);
    return r;
}

References FLAG_FIELD_ALIAS, FLAG_FIELD_COLOR, FLAG_FIELD_COMMENT, FLAG_FIELD_DEMANGLED, FLAG_FIELD_OFFSET, FLAG_FIELD_REALNAME, FLAG_FIELD_SIZE, FLAG_FIELD_SPACE, flag_load_cb(), r, rz_key_parser_add(), rz_key_parser_free(), rz_key_parser_new(), and sdb_foreach().

Referenced by rz_serialize_flag_load().

rz_serialize_flag_load()

RZ_API bool rz_serialize_flag_load	(	RZ_NONNULL Sdb *	db,
		RZ_NONNULL RzFlag *	flag,
		RZ_NULLABLE RzSerializeResultInfo *	res
	)

Definition at line 270 of file serialize_flag.c.

                                                                                                                        {
    rz_flag_unset_all(flag);
 
    const char *str = sdb_const_get(db, "base", NULL);
    if (!str) {
        RZ_SERIALIZE_ERR(res, "flag base key is missing");
        return false;
    }
    flag->base = strtoll(str, NULL, 0);
 
    str = sdb_const_get(db, "realnames", 0);
    if (!str) {
        RZ_SERIALIZE_ERR(res, "flag realnames key is missing");
        return false;
    }
    flag->realnames = strtoul(str, NULL, 0) ? true : false;
 
    Sdb *spaces_db = sdb_ns(db, "spaces", false);
    if (!spaces_db) {
        RZ_SERIALIZE_ERR(res, "missing spaces namespace");
        return false;
    }
    if (!rz_serialize_spaces_load(spaces_db, &flag->spaces, false, res)) {
        return false;
    }
 
    Sdb *tags_db = sdb_ns(db, "tags", false);
    if (!tags_db) {
        RZ_SERIALIZE_ERR(res, "missing tags namespace");
        return false;
    }
    sdb_copy(tags_db, flag->tags);
 
    Sdb *zones_db = sdb_ns(db, "zones", false);
    if (!zones_db) {
        RZ_SERIALIZE_ERR(res, "missing zones namespace");
        return false;
    }
    rz_flag_zone_reset(flag);
    if (!rz_serialize_flag_zones_load(zones_db, flag->zones, res)) {
        return false;
    }
 
    Sdb *flags_db = sdb_ns(db, "flags", false);
    if (!flags_db) {
        RZ_SERIALIZE_ERR(res, "missing flags sub-namespace");
        return false;
    }
    if (!load_flags(flags_db, flag)) {
        RZ_SERIALIZE_ERR(res, "failed to parse a flag json");
        return false;
    }
 
    return true;
}

References load_flags(), NULL, rz_flag_unset_all(), rz_flag_zone_reset(), RZ_SERIALIZE_ERR, rz_serialize_flag_zones_load(), rz_serialize_spaces_load(), sdb_const_get(), sdb_copy(), sdb_ns(), cmd_descs_generate::str, and true.

Referenced by rz_serialize_core_load().

rz_serialize_flag_save()

RZ_API void rz_serialize_flag_save	(	RZ_NONNULL Sdb *	db,
		RZ_NONNULL RzFlag *	flag
	)

Definition at line 123 of file serialize_flag.c.

                                                                                {
    rz_serialize_spaces_save(sdb_ns(db, "spaces", true), &flag->spaces);
    char buf[32];
    if (snprintf(buf, sizeof(buf), "%" PFMT64d, flag->base) < 0) {
        return;
    }
    sdb_set(db, "base", buf, 0);
    sdb_set(db, "realnames", flag->realnames ? "1" : "0", 0);
    sdb_copy(flag->tags, sdb_ns(db, "tags", true));
    rz_serialize_flag_zones_save(sdb_ns(db, "zones", true), flag->zones);
    rz_flag_foreach(flag, flag_save_cb, sdb_ns(db, "flags", true));
}

References flag_save_cb(), PFMT64d, rz_flag_foreach(), rz_serialize_flag_zones_save(), rz_serialize_spaces_save(), sdb_copy(), sdb_ns(), sdb_set(), and snprintf.

Referenced by rz_serialize_core_save().

rz_serialize_flag_zones_load()

RZ_API bool rz_serialize_flag_zones_load	(	RZ_NONNULL Sdb *	db,
		RZ_NONNULL RzList *	zones,
		RZ_NULLABLE RzSerializeResultInfo *	res
	)

Definition at line 82 of file serialize_flag.c.

                                                                                                                                 {
    rz_return_val_if_fail(zones, false);
    rz_list_purge(zones);
    bool r = sdb_foreach(db, zone_load_cb, zones);
    if (!r) {
        RZ_SERIALIZE_ERR(res, "failed to parse a flag zone json");
    }
    return r;
}

References r, rz_list_purge(), rz_return_val_if_fail, RZ_SERIALIZE_ERR, sdb_foreach(), and zone_load_cb().

Referenced by rz_serialize_flag_load().

rz_serialize_flag_zones_save()

RZ_API void rz_serialize_flag_zones_save	(	RZ_NONNULL Sdb *	db,
		RZ_NONNULL RzList *	zones
	)

Definition at line 24 of file serialize_flag.c.

                                                                                         {
    RzListIter *it;
    RzFlagZoneItem *item;
    rz_list_foreach (zones, it, item) {
        PJ *j = pj_new();
        if (!j) {
            return;
        }
        pj_o(j);
        pj_kn(j, "from", item->from);
        pj_kn(j, "to", item->to);
        pj_end(j);
        sdb_set(db, item->name, pj_string(j), 0);
        pj_free(j);
    }
}

References rz_flag_zone_item_t::from, rz_flag_zone_item_t::name, pj_end(), pj_free(), pj_kn(), pj_new(), pj_o(), pj_string(), sdb_set(), and rz_flag_zone_item_t::to.

Referenced by rz_serialize_flag_save().

zone_load_cb()

static bool zone_load_cb ( void *  user, const char *  k, const char *  v  )

static

Definition at line 41 of file serialize_flag.c.

                                                                   {
    RzList *list = user;
    char *json_str = strdup(v);
    if (!json_str) {
        return true;
    }
    RzJson *json = rz_json_parse(json_str);
    if (!json) {
        free(json_str);
        return true;
    }
    if (json->type != RZ_JSON_OBJECT) {
        goto beach;
    }
    const RzJson *child;
    RzFlagZoneItem *item = RZ_NEW0(RzFlagZoneItem);
    if (!item) {
        goto beach;
    }
    item->name = strdup(k);
    if (!item->name) {
        free(item);
        goto beach;
    }
    for (child = json->children.first; child; child = child->next) {
        if (child->type != RZ_JSON_INTEGER) {
            continue;
        }
        if (strcmp(child->key, "from") == 0) {
            item->from = child->num.u_value;
        } else if (strcmp(child->key, "to") == 0) {
            item->to = child->num.u_value;
        }
    }
    rz_list_append(list, item);
beach:
    rz_json_free(json);
    free(json_str);
    return true;
}

References rz_json_t::children, free(), rz_flag_zone_item_t::from, k, rz_json_t::key, list(), rz_flag_zone_item_t::name, rz_json_t::next, rz_json_t::num, rz_json_free(), RZ_JSON_INTEGER, RZ_JSON_OBJECT, rz_json_parse(), rz_list_append(), RZ_NEW0, strdup(), rz_flag_zone_item_t::to, rz_json_t::type, and v.

Referenced by rz_serialize_flag_zones_load().