#include <rz_util/rz_serialize.h>
#include <rz_list.h>
#include <rz_vector.h>
#include <rz_type.h>
#include <sdb.h>

Classes
struct	TypeFormatPair

struct	typedb_sdb

Functions
static RzTypeTypeclass	get_base_type_typeclass (RZ_NONNULL const RzBaseType *type)

static void	set_base_type_typeclass (RZ_NONNULL RzBaseType *type, RzTypeTypeclass typeclass)

static char *	get_type_data (Sdb sdb, const char type, const char *sname)

static TypeFormatPair *	get_enum_type (Sdb sdb, const char sname)

static TypeFormatPair *	get_struct_type (RzTypeDB typedb, Sdb sdb, const char *sname)

static TypeFormatPair *	get_union_type (RzTypeDB typedb, Sdb sdb, const char *sname)

static TypeFormatPair *	get_typedef_type (RzTypeDB typedb, Sdb sdb, const char *sname)

static TypeFormatPair *	get_atomic_type (RzTypeDB typedb, Sdb sdb, const char *sname)

bool	sdb_load_base_types (RzTypeDB typedb, Sdb sdb)

static void	save_struct (const RzTypeDB typedb, Sdb sdb, const RzBaseType *type)

static void	save_union (const RzTypeDB typedb, Sdb sdb, const RzBaseType *type)

static void	save_enum (const RzTypeDB typedb, Sdb sdb, const RzBaseType *type)

static void	save_atomic_type (const RzTypeDB typedb, Sdb sdb, const RzBaseType *type)

static void	save_typedef (const RzTypeDB typedb, Sdb sdb, const RzBaseType *type)

void	sdb_save_base_type (const RzTypeDB typedb, RZ_NONNULL Sdb sdb, const RzBaseType *type)

RZ_IPI bool	types_load_sdb (RZ_NONNULL Sdb db, RZ_NONNULL RzTypeDB typedb)

static bool	export_base_type_cb (void user, const void k, const void *v)

static bool	types_export_sdb (RZ_NONNULL Sdb db, RZ_NONNULL const RzTypeDB typedb)

static bool	sdb_load_by_path (RZ_NONNULL RzTypeDB typedb, RZ_NONNULL const char path)

static bool	sdb_load_from_string (RZ_NONNULL RzTypeDB typedb, RZ_NONNULL const char string)

RZ_API bool	rz_type_db_load_sdb (RzTypeDB typedb, RZ_NONNULL const char path)
	Loads the types from compiled SDB specified by path. More...

RZ_API bool	rz_type_db_load_sdb_str (RzTypeDB typedb, RZ_NONNULL const char str)
	Loads the types from SDB KV string. More...

RZ_API void	rz_serialize_types_save (RZ_NONNULL Sdb db, RZ_NONNULL const RzTypeDB typedb)
	Saves the types into SDB. More...

RZ_API bool	rz_serialize_types_load (RZ_NONNULL Sdb db, RZ_NONNULL RzTypeDB typedb, RZ_NULLABLE RzSerializeResultInfo *res)
	Loads the types from SDB. More...

Function Documentation

◆ export_base_type_cb()

static bool export_base_type_cb	(	void *	user,
		const void *	k,
		const void *	v
	)

static

Definition at line 604 of file serialize_types.c.

                                                                           {
     struct typedb_sdb *s = user;
     RzBaseType *btype = (RzBaseType *)v;
     sdb_save_base_type(s->typedb, s->sdb, btype);
     return true;
 }

References s, sdb_save_base_type(), and v.

Referenced by types_export_sdb().

◆ get_atomic_type()

static TypeFormatPair* get_atomic_type	(	RzTypeDB *	typedb,
		Sdb *	sdb,
		const char *	sname
	)

static

Definition at line 278 of file serialize_types.c.

                                                                                       {
     rz_return_val_if_fail(typedb && sdb && RZ_STR_ISNOTEMPTY(sname), NULL);
  
     RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_ATOMIC);
     if (!base_type) {
         return NULL;
     }
  
     RzType *ttype = RZ_NEW0(RzType);
     if (!ttype) {
         goto error;
     }
     ttype->kind = RZ_TYPE_KIND_IDENTIFIER;
     ttype->identifier.name = strdup(sname);
     ttype->identifier.is_const = false; // We don't preload const types by default
     ttype->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED;
     base_type->type = ttype;
  
     base_type->name = strdup(sname);
     RzStrBuf key;
     base_type->size = sdb_num_get(sdb, rz_strbuf_initf(&key, "type.%s.size", sname), 0);
     RzTypeTypeclass typeclass = RZ_TYPE_TYPECLASS_NONE;
     const char *tclass = sdb_const_get(sdb, rz_strbuf_setf(&key, "type.%s.typeclass", sname), 0);
     if (tclass) {
         typeclass = rz_type_typeclass_from_string(tclass);
     }
     set_base_type_typeclass(base_type, typeclass);
     const char *format = sdb_const_get(sdb, rz_strbuf_setf(&key, "type.%s", sname), 0);
     rz_strbuf_fini(&key);
  
     TypeFormatPair *tpair = RZ_NEW0(TypeFormatPair);
     tpair->type = base_type;
     tpair->format = format ? strdup(format) : NULL;
  
     return tpair;
  
 error:
     rz_type_base_type_free(base_type);
     return NULL;
 }

References error(), TypeFormatPair::format, rz_type_t::identifier, key, rz_type_t::kind, rz_base_type_t::name, NULL, RZ_BASE_TYPE_KIND_ATOMIC, RZ_NEW0, rz_return_val_if_fail, RZ_STR_ISNOTEMPTY, rz_strbuf_fini(), rz_strbuf_initf(), rz_strbuf_setf(), rz_type_base_type_free(), rz_type_base_type_new(), RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED, RZ_TYPE_KIND_IDENTIFIER, rz_type_typeclass_from_string(), RZ_TYPE_TYPECLASS_NONE, sdb_const_get(), sdb_num_get(), set_base_type_typeclass(), rz_base_type_t::size, strdup(), rz_base_type_t::type, and TypeFormatPair::type.

Referenced by sdb_load_base_types().

◆ get_base_type_typeclass()

static RzTypeTypeclass get_base_type_typeclass ( RZ_NONNULL const RzBaseType * type )

inlinestatic

Definition at line 15 of file serialize_types.c.

                                                                                          {
     rz_return_val_if_fail(type, RZ_TYPE_TYPECLASS_INVALID);
     return type->attrs & RZ_TYPE_ATTRIBUTE_TYPECLASS_MASK;
 }

References rz_return_val_if_fail, RZ_TYPE_ATTRIBUTE_TYPECLASS_MASK, RZ_TYPE_TYPECLASS_INVALID, and type.

Referenced by save_atomic_type().

◆ get_enum_type()

static TypeFormatPair* get_enum_type	(	Sdb *	sdb,
		const char *	sname
	)

static

Definition at line 36 of file serialize_types.c.

                                                                   {
     rz_return_val_if_fail(sdb && RZ_STR_ISNOTEMPTY(sname), NULL);
  
     RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_ENUM);
     if (!base_type) {
         return NULL;
     }
  
     char *members = get_type_data(sdb, "enum", sname);
     if (!members) {
         goto error;
     }
  
     base_type->name = strdup(sname);
     RzVector *cases = &base_type->enum_data.cases;
     if (!rz_vector_reserve(cases, (size_t)sdb_alen(members))) {
         goto error;
     }
  
     char *cur;
     sdb_aforeach(cur, members) {
         char *val_key = rz_str_newf("enum.%s.%s", sname, cur);
         if (!val_key) {
             goto error;
         }
         const char *value = sdb_const_get(sdb, val_key, NULL);
         free(val_key);
  
         if (!value) { // if nothing is found, ret NULL
             goto error;
         }
  
         RzTypeEnumCase cas = { .name = strdup(cur), .val = strtol(value, NULL, 16) };
  
         void *element = rz_vector_push(cases, &cas); // returns null if no space available
         if (!element) {
             goto error;
         }
  
         sdb_aforeach_next(cur);
     }
     free(members);
  
     RzStrBuf key;
     char *format = sdb_get(sdb, rz_strbuf_initf(&key, "type.%s", sname), 0);
     rz_strbuf_fini(&key);
  
     TypeFormatPair *tpair = RZ_NEW0(TypeFormatPair);
     tpair->type = base_type;
     tpair->format = format;
  
     return tpair;
  
 error:
     free(members);
     rz_type_base_type_free(base_type);
     return NULL;
 }

References rz_base_type_enum_t::cases, rz_base_type_t::enum_data, error(), TypeFormatPair::format, free(), get_type_data(), key, rz_type_enum_case_t::name, rz_base_type_t::name, NULL, RZ_BASE_TYPE_KIND_ENUM, RZ_NEW0, rz_return_val_if_fail, RZ_STR_ISNOTEMPTY, rz_str_newf(), rz_strbuf_fini(), rz_strbuf_initf(), rz_type_base_type_free(), rz_type_base_type_new(), rz_vector_push(), rz_vector_reserve(), sdb_aforeach, sdb_aforeach_next, sdb_alen(), sdb_const_get(), sdb_get(), strdup(), TypeFormatPair::type, and value.

Referenced by sdb_load_base_types().

◆ get_struct_type()

static TypeFormatPair* get_struct_type	(	RzTypeDB *	typedb,
		Sdb *	sdb,
		const char *	sname
	)

static

Definition at line 95 of file serialize_types.c.

                                                                                       {
     rz_return_val_if_fail(typedb && sdb && RZ_STR_ISNOTEMPTY(sname), NULL);
  
     RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_STRUCT);
     if (!base_type) {
         return NULL;
     }
     base_type->name = strdup(sname);
  
     char *sdb_members = get_type_data(sdb, "struct", sname);
     if (sdb_members) {
         RzVector *members = &base_type->struct_data.members;
         if (!rz_vector_reserve(members, (size_t)sdb_alen(sdb_members))) {
             goto error;
         }
  
         char *cur;
         sdb_aforeach(cur, sdb_members) {
             char *type_key = rz_str_newf("struct.%s.%s", sname, cur);
             if (!type_key) {
                 goto error;
             }
             char *values = sdb_get(sdb, type_key, NULL);
             free(type_key);
  
             if (!values) {
                 goto error;
             }
             char *offset = NULL;
             char *type = sdb_anext(values, &offset);
             if (!offset) { // offset is missing, malformed state
                 free(values);
                 goto error;
             }
             // Parse type as a C string
             char *error_msg = NULL;
             RzType *ttype = rz_type_parse_string_single(typedb->parser, type, &error_msg);
             if (!ttype || error_msg) {
                 free(values);
                 goto error;
             }
  
             RzTypeStructMember memb = {
                 .name = strdup(cur),
                 .type = ttype,
                 .offset = strtol(offset, NULL, 10)
             };
  
             free(values);
  
             void *element = rz_vector_push(members, &memb); // returns null if no space available
             if (!element) {
                 goto error;
             }
  
             sdb_aforeach_next(cur);
         }
         free(sdb_members);
     }
  
     RzStrBuf key;
     const char *format = sdb_get(sdb, rz_strbuf_initf(&key, "type.%s", sname), 0);
     rz_strbuf_fini(&key);
  
     TypeFormatPair *tpair = RZ_NEW0(TypeFormatPair);
     tpair->type = base_type;
     tpair->format = format ? strdup(format) : NULL;
  
     return tpair;
  
 error:
     rz_type_base_type_free(base_type);
     free(sdb_members);
     return NULL;
 }

References error(), TypeFormatPair::format, free(), get_type_data(), key, rz_base_type_struct_t::members, rz_type_struct_member_t::name, rz_base_type_t::name, NULL, rz_type_db_t::parser, RZ_BASE_TYPE_KIND_STRUCT, RZ_NEW0, rz_return_val_if_fail, RZ_STR_ISNOTEMPTY, rz_str_newf(), rz_strbuf_fini(), rz_strbuf_initf(), rz_type_base_type_free(), rz_type_base_type_new(), rz_type_parse_string_single(), rz_vector_push(), rz_vector_reserve(), sdb_aforeach, sdb_aforeach_next, sdb_alen(), sdb_anext(), sdb_get(), strdup(), rz_base_type_t::struct_data, type, and TypeFormatPair::type.

Referenced by sdb_load_base_types().

◆ get_type_data()

static char* get_type_data	(	Sdb *	sdb,
		const char *	type,
		const char *	sname
	)

static

Definition at line 25 of file serialize_types.c.

                                                                           {
     rz_return_val_if_fail(sdb && RZ_STR_ISNOTEMPTY(type) && RZ_STR_ISNOTEMPTY(sname), NULL);
     char *key = rz_str_newf("%s.%s", type, sname);
     if (!key) {
         return NULL;
     }
     char *members = sdb_get(sdb, key, NULL);
     free(key);
     return members;
 }

References free(), key, NULL, rz_return_val_if_fail, RZ_STR_ISNOTEMPTY, rz_str_newf(), sdb_get(), and type.

Referenced by get_enum_type(), get_struct_type(), get_typedef_type(), and get_union_type().

◆ get_typedef_type()

static TypeFormatPair* get_typedef_type	(	RzTypeDB *	typedb,
		Sdb *	sdb,
		const char *	sname
	)

static

Definition at line 240 of file serialize_types.c.

                                                                                        {
     rz_return_val_if_fail(typedb && sdb && RZ_STR_ISNOTEMPTY(sname), NULL);
  
     RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_TYPEDEF);
     if (!base_type) {
         return NULL;
     }
  
     base_type->name = strdup(sname);
     char *type = get_type_data(sdb, "typedef", sname);
     char *error_msg = NULL;
     RzType *ttype = rz_type_parse_string_single(typedb->parser, type, &error_msg);
     if (!ttype || error_msg) {
         goto error;
     }
     free(type);
  
     base_type->type = ttype;
     if (!base_type->type) {
         goto error;
     }
  
     RzStrBuf key;
     char *format = sdb_get(sdb, rz_strbuf_initf(&key, "type.%s", sname), 0);
     rz_strbuf_fini(&key);
  
     TypeFormatPair *tpair = RZ_NEW0(TypeFormatPair);
     tpair->type = base_type;
     tpair->format = format;
  
     return tpair;
  
 error:
     free(type);
     rz_type_base_type_free(base_type);
     return NULL;
 }

References error(), TypeFormatPair::format, free(), get_type_data(), key, rz_base_type_t::name, NULL, rz_type_db_t::parser, RZ_BASE_TYPE_KIND_TYPEDEF, RZ_NEW0, rz_return_val_if_fail, RZ_STR_ISNOTEMPTY, rz_strbuf_fini(), rz_strbuf_initf(), rz_type_base_type_free(), rz_type_base_type_new(), rz_type_parse_string_single(), sdb_get(), strdup(), type, rz_base_type_t::type, and TypeFormatPair::type.

Referenced by sdb_load_base_types().

◆ get_union_type()

static TypeFormatPair* get_union_type	(	RzTypeDB *	typedb,
		Sdb *	sdb,
		const char *	sname
	)

static

Definition at line 171 of file serialize_types.c.

                                                                                      {
     rz_return_val_if_fail(typedb && sdb && RZ_STR_ISNOTEMPTY(sname), NULL);
  
     RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_UNION);
     if (!base_type) {
         return NULL;
     }
  
     base_type->name = strdup(sname);
  
     char *sdb_members = get_type_data(sdb, "union", sname);
     if (sdb_members) {
         RzVector *members = &base_type->union_data.members;
         if (!rz_vector_reserve(members, (size_t)sdb_alen(sdb_members))) {
             goto error;
         }
  
         char *cur;
         sdb_aforeach(cur, sdb_members) {
             char *type_key = rz_str_newf("union.%s.%s", sname, cur);
             if (!type_key) {
                 goto error;
             }
             char *values = sdb_get(sdb, type_key, NULL);
             free(type_key);
  
             if (!values) {
                 goto error;
             }
             char *value = sdb_anext(values, NULL);
             char *error_msg = NULL;
             RzType *ttype = rz_type_parse_string_single(typedb->parser, value, &error_msg);
             if (!ttype || error_msg) {
                 free(values);
                 goto error;
             }
  
             RzTypeUnionMember memb = {
                 .name = strdup(cur),
                 .type = ttype
             };
             free(values);
  
             void *element = rz_vector_push(members, &memb); // returns null if no space available
             if (!element) {
                 goto error;
             }
  
             sdb_aforeach_next(cur);
         }
         free(sdb_members);
     }
  
     RzStrBuf key;
     const char *format = sdb_get(sdb, rz_strbuf_initf(&key, "type.%s", sname), 0);
     rz_strbuf_fini(&key);
  
     TypeFormatPair *tpair = RZ_NEW0(TypeFormatPair);
     tpair->type = base_type;
     tpair->format = format ? strdup(format) : NULL;
  
     return tpair;
  
 error:
     rz_type_base_type_free(base_type);
     free(sdb_members);
     return NULL;
 }

References error(), TypeFormatPair::format, free(), get_type_data(), key, rz_base_type_union_t::members, rz_type_union_member_t::name, rz_base_type_t::name, NULL, rz_type_db_t::parser, RZ_BASE_TYPE_KIND_UNION, RZ_NEW0, rz_return_val_if_fail, RZ_STR_ISNOTEMPTY, rz_str_newf(), rz_strbuf_fini(), rz_strbuf_initf(), rz_type_base_type_free(), rz_type_base_type_new(), rz_type_parse_string_single(), rz_vector_push(), rz_vector_reserve(), sdb_aforeach, sdb_aforeach_next, sdb_alen(), sdb_anext(), sdb_get(), strdup(), TypeFormatPair::type, rz_base_type_t::union_data, and value.

Referenced by sdb_load_base_types().

◆ rz_serialize_types_load()

RZ_API bool rz_serialize_types_load	(	RZ_NONNULL Sdb *	db,
		RZ_NONNULL RzTypeDB *	typedb,
		RZ_NULLABLE RzSerializeResultInfo *	res
	)

Loads the types from SDB.

Parameters

db	A SDB database object
typedb	RzTypeDB instance
res	A structure where the result is stored

Definition at line 688 of file serialize_types.c.

                                                                                                                              {
     rz_return_val_if_fail(db && typedb, false);
     return types_load_sdb(db, typedb);
 }

References rz_return_val_if_fail, typedb_sdb::typedb, and types_load_sdb().

Referenced by rz_serialize_analysis_types_load().

◆ rz_serialize_types_save()

RZ_API void rz_serialize_types_save	(	RZ_NONNULL Sdb *	db,
		RZ_NONNULL const RzTypeDB *	typedb
	)

Saves the types into SDB.

Parameters

db	A SDB database object
typedb	RzTypeDB instance

Definition at line 676 of file serialize_types.c.

                                                                                            {
     rz_return_if_fail(db && typedb);
     types_export_sdb(db, typedb);
 }

References rz_return_if_fail, typedb_sdb::typedb, and types_export_sdb().

Referenced by rz_serialize_analysis_types_save().

◆ rz_type_db_load_sdb()

RZ_API bool rz_type_db_load_sdb	(	RzTypeDB *	typedb,
		RZ_NONNULL const char *	path
	)

Loads the types from compiled SDB specified by path.

Parameters

typedb	RzTypeDB instance
path	A path to the compiled SDB containing serialized types

Definition at line 648 of file serialize_types.c.

                                                                                {
     rz_return_val_if_fail(typedb && path, false);
     if (!rz_file_exists(path)) {
         return false;
     }
     return sdb_load_by_path(typedb, path);
 }

References path, rz_file_exists(), rz_return_val_if_fail, sdb_load_by_path(), and typedb_sdb::typedb.

Referenced by rz_type_db_init(), and rz_type_open_sdb_handler().

◆ rz_type_db_load_sdb_str()

RZ_API bool rz_type_db_load_sdb_str	(	RzTypeDB *	typedb,
		RZ_NONNULL const char *	str
	)

Loads the types from SDB KV string.

Parameters

typedb	RzTypeDB instance
str	A string in Key-Value format as for non-compiled SDB

Definition at line 662 of file serialize_types.c.

                                                                                   {
     rz_return_val_if_fail(typedb && str, false);
     if (RZ_STR_ISEMPTY(str)) {
         return false;
     }
     return sdb_load_from_string(typedb, str);
 }

References rz_return_val_if_fail, RZ_STR_ISEMPTY, sdb_load_from_string(), cmd_descs_generate::str, and typedb_sdb::typedb.

◆ save_atomic_type()

static void save_atomic_type	(	const RzTypeDB *	typedb,
		Sdb *	sdb,
		const RzBaseType *	type
	)

static

Definition at line 504 of file serialize_types.c.

                                                                                        {
     rz_return_if_fail(typedb && sdb && type && type->name && type->kind == RZ_BASE_TYPE_KIND_ATOMIC);
     /*
         C: (cannot define a custom atomic type)
         Sdb:
         char=type
         type.char=c
         type.char.size=8
         type.char.typeclass=Signed Integral
     */
     char *sname = type->name;
     sdb_set(sdb, sname, "type", 0);
  
     RzStrBuf key;
     RzStrBuf val;
     rz_strbuf_init(&key);
     rz_strbuf_init(&val);
  
     sdb_set(sdb,
         rz_strbuf_setf(&key, "type.%s.size", sname),
         rz_strbuf_setf(&val, "%" PFMT64u "", type->size), 0);
     sdb_set(sdb,
         rz_strbuf_setf(&key, "type.%s.typeclass", sname),
         rz_type_typeclass_as_string(get_base_type_typeclass(type)), 0);
  
     const char *typefmt = rz_type_db_format_get(typedb, sname);
     sdb_set(sdb,
         rz_strbuf_setf(&key, "type.%s", sname),
         typefmt, 0);
  
     rz_strbuf_fini(&key);
     rz_strbuf_fini(&val);
 }

References get_base_type_typeclass(), key, PFMT64u, RZ_BASE_TYPE_KIND_ATOMIC, rz_return_if_fail, rz_strbuf_fini(), rz_strbuf_init(), rz_strbuf_setf(), rz_type_db_format_get(), rz_type_typeclass_as_string(), sdb_set(), type, and val.

Referenced by sdb_save_base_type().

◆ save_enum()

static void save_enum	(	const RzTypeDB *	typedb,
		Sdb *	sdb,
		const RzBaseType *	type
	)

static

Definition at line 453 of file serialize_types.c.

                                                                                 {
     rz_return_if_fail(typedb && sdb && type && type->name && type->kind == RZ_BASE_TYPE_KIND_ENUM);
     /*
         C:
             enum name {case1 = 1, case2 = 2, caseN = 3};
         Sdb:
         name=enum
         enum.name=arg1,arg2,argN
         enum.MyEnum.0x1=arg1
         enum.MyEnum.0x3=arg2
         enum.MyEnum.0x63=argN
         enum.MyEnum.arg1=0x1
         enum.MyEnum.arg2=0x63
         enum.MyEnum.argN=0x3
     */
     char *sname = type->name;
     sdb_set(sdb, sname, "enum", 0);
  
     RzStrBuf arglist;
     RzStrBuf param_key;
     RzStrBuf param_val;
     rz_strbuf_init(&arglist);
     rz_strbuf_init(&param_key);
     rz_strbuf_init(&param_val);
  
     int i = 0;
     RzTypeEnumCase *cas;
     rz_vector_foreach(&type->enum_data.cases, cas) {
         // enum.name.arg1=type,offset,???
         char *case_sname = rz_str_sanitize_sdb_key(cas->name);
         sdb_set(sdb,
             rz_strbuf_setf(&param_key, "enum.%s.%s", sname, case_sname),
             rz_strbuf_setf(&param_val, "0x%" PFMT64x "", cas->val), 0);
  
         sdb_set(sdb,
             rz_strbuf_setf(&param_key, "enum.%s.0x%" PFMT64x "", sname, cas->val),
             case_sname, 0);
         free(case_sname);
  
         rz_strbuf_appendf(&arglist, (i++ == 0) ? "%s" : ",%s", cas->name);
     }
     // enum.name=arg1,arg2,argN
     char *key = rz_str_newf("enum.%s", sname);
     sdb_set(sdb, key, rz_strbuf_get(&arglist), 0);
     free(key);
  
     rz_strbuf_fini(&arglist);
     rz_strbuf_fini(&param_key);
     rz_strbuf_fini(&param_val);
 }

References free(), i, key, rz_type_enum_case_t::name, PFMT64x, RZ_BASE_TYPE_KIND_ENUM, rz_return_if_fail, rz_str_newf(), rz_str_sanitize_sdb_key(), rz_strbuf_appendf(), rz_strbuf_fini(), rz_strbuf_get(), rz_strbuf_init(), rz_strbuf_setf(), rz_vector_foreach, sdb_set(), type, and rz_type_enum_case_t::val.

Referenced by sdb_save_base_type().

◆ save_struct()

static void save_struct	(	const RzTypeDB *	typedb,
		Sdb *	sdb,
		const RzBaseType *	type
	)

static

Definition at line 357 of file serialize_types.c.

                                                                                   {
     rz_return_if_fail(typedb && sdb && type && type->name && type->kind == RZ_BASE_TYPE_KIND_STRUCT);
     const char *kind = "struct";
     /*
         C:
         struct name {type param1; type param2; type paramN;};
         Sdb:
         name=struct
         struct.name=param1,param2,paramN
         struct.name.param1=type,0,0
         struct.name.param2=type,4,0
         struct.name.paramN=type,8,0
     */
     char *sname = type->name;
     // name=struct
     sdb_set(sdb, sname, kind, 0);
  
     RzStrBuf arglist;
     RzStrBuf param_key;
     RzStrBuf param_val;
     rz_strbuf_init(&arglist);
     rz_strbuf_init(&param_key);
     rz_strbuf_init(&param_val);
  
     int i = 0;
     RzTypeStructMember *member;
     rz_vector_foreach(&type->struct_data.members, member) {
         // struct.name.param=type,offset,argsize
         char *member_sname = rz_str_sanitize_sdb_key(member->name);
         char *member_type = rz_type_as_string(typedb, member->type);
         sdb_set(sdb,
             rz_strbuf_setf(&param_key, "%s.%s.%s", kind, sname, member_sname),
             rz_strbuf_setf(&param_val, "%s,%zu,%u", member_type, member->offset, 0), 0ULL);
         free(member_type);
         free(member_sname);
  
         rz_strbuf_appendf(&arglist, (i++ == 0) ? "%s" : ",%s", member->name);
     }
     // struct.name=param1,param2,paramN
     char *key = rz_str_newf("%s.%s", kind, sname);
     sdb_set(sdb, key, rz_strbuf_get(&arglist), 0);
     free(key);
  
     rz_strbuf_fini(&arglist);
     rz_strbuf_fini(&param_key);
     rz_strbuf_fini(&param_val);
 }

References free(), i, key, rz_type_struct_member_t::name, rz_type_struct_member_t::offset, RZ_BASE_TYPE_KIND_STRUCT, rz_return_if_fail, rz_str_newf(), rz_str_sanitize_sdb_key(), rz_strbuf_appendf(), rz_strbuf_fini(), rz_strbuf_get(), rz_strbuf_init(), rz_strbuf_setf(), rz_type_as_string(), rz_vector_foreach, sdb_set(), type, and rz_type_struct_member_t::type.

Referenced by sdb_save_base_type().

◆ save_typedef()

static void save_typedef	(	const RzTypeDB *	typedb,
		Sdb *	sdb,
		const RzBaseType *	type
	)

static

Definition at line 538 of file serialize_types.c.

                                                                                    {
     rz_return_if_fail(typedb && sdb && type && type->name && type->kind == RZ_BASE_TYPE_KIND_TYPEDEF);
     /*
         C:
         typedef char byte;
         Sdb:
         byte=typedef
         typedef.byte=char
     */
     char *sname = type->name;
     sdb_set(sdb, sname, "typedef", 0);
  
     RzStrBuf key;
     RzStrBuf val;
     rz_strbuf_init(&key);
     rz_strbuf_init(&val);
  
     char *ttype = rz_type_as_string(typedb, type->type);
     sdb_set(sdb,
         rz_strbuf_setf(&key, "typedef.%s", sname),
         rz_strbuf_setf(&val, "%s", ttype), 0);
  
     free(ttype);
  
     rz_strbuf_fini(&key);
     rz_strbuf_fini(&val);
 }

References free(), key, RZ_BASE_TYPE_KIND_TYPEDEF, rz_return_if_fail, rz_strbuf_fini(), rz_strbuf_init(), rz_strbuf_setf(), rz_type_as_string(), sdb_set(), type, and val.

Referenced by sdb_save_base_type().

◆ save_union()

static void save_union	(	const RzTypeDB *	typedb,
		Sdb *	sdb,
		const RzBaseType *	type
	)

static

Definition at line 405 of file serialize_types.c.

                                                                                  {
     rz_return_if_fail(typedb && sdb && type && type->name && type->kind == RZ_BASE_TYPE_KIND_UNION);
     const char *kind = "union";
     /*
     C:
     union name {type param1; type param2; type paramN;};
     Sdb:
     name=union
     union.name=param1,param2,paramN
     union.name.param1=type,0,0
     union.name.param2=type,0,0
     union.name.paramN=type,0,0
     */
     char *sname = type->name;
     // name=union
     sdb_set(sdb, sname, kind, 0);
  
     RzStrBuf arglist;
     RzStrBuf param_key;
     RzStrBuf param_val;
     rz_strbuf_init(&arglist);
     rz_strbuf_init(&param_key);
     rz_strbuf_init(&param_val);
  
     int i = 0;
     RzTypeUnionMember *member;
     rz_vector_foreach(&type->union_data.members, member) {
         // union.name.arg1=type,offset,argsize
         char *member_sname = rz_str_sanitize_sdb_key(member->name);
         char *member_type = rz_type_as_string(typedb, member->type);
         sdb_set(sdb,
             rz_strbuf_setf(&param_key, "%s.%s.%s", kind, sname, member_sname),
             rz_strbuf_setf(&param_val, "%s,%zu,%u", member_type, member->offset, 0), 0ULL);
         free(member_type);
         free(member_sname);
  
         rz_strbuf_appendf(&arglist, (i++ == 0) ? "%s" : ",%s", member->name);
     }
     // union.name=arg1,arg2,argN
     char *key = rz_str_newf("%s.%s", kind, sname);
     sdb_set(sdb, key, rz_strbuf_get(&arglist), 0);
     free(key);
  
     rz_strbuf_fini(&arglist);
     rz_strbuf_fini(&param_key);
     rz_strbuf_fini(&param_val);
 }

References free(), i, key, rz_type_union_member_t::name, rz_type_union_member_t::offset, RZ_BASE_TYPE_KIND_UNION, rz_return_if_fail, rz_str_newf(), rz_str_sanitize_sdb_key(), rz_strbuf_appendf(), rz_strbuf_fini(), rz_strbuf_get(), rz_strbuf_init(), rz_strbuf_setf(), rz_type_as_string(), rz_vector_foreach, sdb_set(), type, and rz_type_union_member_t::type.

Referenced by sdb_save_base_type().

◆ sdb_load_base_types()

bool sdb_load_base_types	(	RzTypeDB *	typedb,
		Sdb *	sdb
	)

Definition at line 319 of file serialize_types.c.

                                                      {
     rz_return_val_if_fail(typedb && sdb, false);
     SdbKv *kv;
     SdbListIter *iter;
     SdbList *l = sdb_foreach_list(sdb, false);
     ls_foreach (l, iter, kv) {
         TypeFormatPair *tpair = NULL;
         if (!strcmp(sdbkv_value(kv), "struct")) {
             tpair = get_struct_type(typedb, sdb, sdbkv_key(kv));
         } else if (!strcmp(sdbkv_value(kv), "enum")) {
             tpair = get_enum_type(sdb, sdbkv_key(kv));
         } else if (!strcmp(sdbkv_value(kv), "union")) {
             tpair = get_union_type(typedb, sdb, sdbkv_key(kv));
         } else if (!strcmp(sdbkv_value(kv), "typedef")) {
             tpair = get_typedef_type(typedb, sdb, sdbkv_key(kv));
         } else if (!strcmp(sdbkv_value(kv), "type")) {
             tpair = get_atomic_type(typedb, sdb, sdbkv_key(kv));
         }
         if (tpair && tpair->type) {
             ht_pp_update(typedb->types, tpair->type->name, tpair->type);
             // If the SDB provided the preferred type format then we store it
             char *format = tpair->format ? tpair->format : NULL;
             // Format is not always defined, e.g. for types like "void" or anonymous types
             if (format) {
                 ht_pp_update(typedb->formats, tpair->type->name, format);
                 RZ_LOG_DEBUG("inserting the \"%s\" type & format: \"%s\"\n", tpair->type->name, format);
             } else {
                 ht_pp_delete(typedb->formats, tpair->type->name);
             }
         } else if (tpair) {
             free(tpair->format);
         }
         free(tpair);
     }
     ls_free(l);
     return true;
 }

References TypeFormatPair::format, rz_type_db_t::formats, free(), get_atomic_type(), get_enum_type(), get_struct_type(), get_typedef_type(), get_union_type(), ls_foreach, ls_free(), rz_base_type_t::name, NULL, RZ_LOG_DEBUG, rz_return_val_if_fail, sdb_foreach_list(), sdbkv_key(), sdbkv_value(), TypeFormatPair::type, and rz_type_db_t::types.

Referenced by types_load_sdb().

◆ sdb_load_by_path()

static bool sdb_load_by_path	(	RZ_NONNULL RzTypeDB *	typedb,
		RZ_NONNULL const char *	path
	)

static

Definition at line 617 of file serialize_types.c.

                                                                                        {
     rz_return_val_if_fail(typedb && path, false);
     if (RZ_STR_ISEMPTY(path)) {
         return false;
     }
     Sdb *db = sdb_new(0, path, 0);
     bool result = types_load_sdb(db, typedb);
     sdb_close(db);
     sdb_free(db);
     return result;
 }

References path, rz_return_val_if_fail, RZ_STR_ISEMPTY, sdb_close(), sdb_free(), sdb_new(), typedb_sdb::typedb, and types_load_sdb().

Referenced by rz_type_db_load_sdb().

◆ sdb_load_from_string()

static bool sdb_load_from_string	(	RZ_NONNULL RzTypeDB *	typedb,
		RZ_NONNULL const char *	string
	)

static

Definition at line 629 of file serialize_types.c.

                                                                                              {
     rz_return_val_if_fail(typedb && string, false);
     if (RZ_STR_ISEMPTY(string)) {
         return false;
     }
     Sdb *db = sdb_new0();
     sdb_query_lines(db, string);
     bool result = types_load_sdb(db, typedb);
     sdb_close(db);
     sdb_free(db);
     return result;
 }

References rz_return_val_if_fail, RZ_STR_ISEMPTY, sdb_close(), sdb_free(), sdb_new0(), sdb_query_lines(), typedb_sdb::typedb, and types_load_sdb().

Referenced by rz_type_db_load_sdb_str().

◆ sdb_save_base_type()

void sdb_save_base_type	(	const RzTypeDB *	typedb,
		RZ_NONNULL Sdb *	sdb,
		const RzBaseType *	type
	)

Definition at line 566 of file serialize_types.c.

                                                                                              {
     rz_return_if_fail(typedb && sdb && type && type->name);
  
     switch (type->kind) {
     case RZ_BASE_TYPE_KIND_STRUCT:
         RZ_LOG_DEBUG("Serializing struct \"%s\"\n", type->name);
         save_struct(typedb, sdb, type);
         break;
     case RZ_BASE_TYPE_KIND_ENUM:
         RZ_LOG_DEBUG("Serializing enum \"%s\"\n", type->name);
         save_enum(typedb, sdb, type);
         break;
     case RZ_BASE_TYPE_KIND_UNION:
         RZ_LOG_DEBUG("Serializing union \"%s\"\n", type->name);
         save_union(typedb, sdb, type);
         break;
     case RZ_BASE_TYPE_KIND_TYPEDEF:
         RZ_LOG_DEBUG("Serializing type alias \"%s\"\n", type->name);
         save_typedef(typedb, sdb, type);
         break;
     case RZ_BASE_TYPE_KIND_ATOMIC:
         RZ_LOG_DEBUG("Serializing atomic type \"%s\"\n", type->name);
         save_atomic_type(typedb, sdb, type);
         break;
     default:
         break;
     }
 }

References RZ_BASE_TYPE_KIND_ATOMIC, RZ_BASE_TYPE_KIND_ENUM, RZ_BASE_TYPE_KIND_STRUCT, RZ_BASE_TYPE_KIND_TYPEDEF, RZ_BASE_TYPE_KIND_UNION, RZ_LOG_DEBUG, rz_return_if_fail, save_atomic_type(), save_enum(), save_struct(), save_typedef(), save_union(), and type.

Referenced by export_base_type_cb().

◆ set_base_type_typeclass()

static void set_base_type_typeclass	(	RZ_NONNULL RzBaseType *	type,
		RzTypeTypeclass	typeclass
	)

inlinestatic

Definition at line 20 of file serialize_types.c.

                                                                                                    {
     rz_return_if_fail(type && typeclass < RZ_TYPE_TYPECLASS_INVALID);
     type->attrs = typeclass;
 }

References rz_return_if_fail, RZ_TYPE_TYPECLASS_INVALID, and type.

Referenced by get_atomic_type().

◆ types_export_sdb()

static bool types_export_sdb	(	RZ_NONNULL Sdb *	db,
		RZ_NONNULL const RzTypeDB *	typedb
	)

static

Definition at line 611 of file serialize_types.c.

                                                                                     {
     struct typedb_sdb tdb = { typedb, db };
     ht_pp_foreach(typedb->types, export_base_type_cb, &tdb);
     return true;
 }

References export_base_type_cb(), typedb_sdb::typedb, and rz_type_db_t::types.

Referenced by rz_serialize_types_save().

◆ types_load_sdb()

RZ_IPI bool types_load_sdb	(	RZ_NONNULL Sdb *	db,
		RZ_NONNULL RzTypeDB *	typedb
	)

Definition at line 595 of file serialize_types.c.

                                                                             {
     return sdb_load_base_types(typedb, db);
 }

References sdb_load_base_types().

Referenced by rz_serialize_types_load(), sdb_load_by_path(), and sdb_load_from_string().

Classes

Functions

Function Documentation

◆ export_base_type_cb()

◆ get_atomic_type()

◆ get_base_type_typeclass()

◆ get_enum_type()

◆ get_struct_type()

◆ get_type_data()

◆ get_typedef_type()

◆ get_union_type()

◆ rz_serialize_types_load()

◆ rz_serialize_types_save()

◆ rz_type_db_load_sdb()

◆ rz_type_db_load_sdb_str()

◆ save_atomic_type()

◆ save_enum()

◆ save_struct()

◆ save_typedef()

◆ save_union()

◆ sdb_load_base_types()

◆ sdb_load_by_path()

◆ sdb_load_from_string()

◆ sdb_save_base_type()

◆ set_base_type_typeclass()

◆ types_export_sdb()

◆ types_load_sdb()