static void dl_load_txt_build_default_data( dl_ctx_t ctx, dl_txt_read_ctx* read_state, unsigned int member_index )
{
if( ctx->member_descs[member_index].default_value_offset == 0xFFFFFFFF )
return;
// TODO: check that this is not outside the buffers
dl_type_desc* def_type = dl_alloc_type( ctx, dl_internal_hash_string( "a_type_here" ) );
dl_member_desc* def_member = dl_alloc_member( ctx );
dl_member_desc* member = &ctx->member_descs[member_index];
uint32_t def_start = member->default_value_offset;
uint32_t def_len = member->default_value_size;
char def_buffer[2048]; // TODO: no hardcode =/
// TODO: check that typename do not exist in the ctx!
size_t name_start = ctx->typedata_strings_size;
dl_txt_read_substr temp = { "a_type_here", 11 };
def_type->name = dl_alloc_string( ctx, &temp );
def_type->size[DL_PTR_SIZE_HOST] = member->size[DL_PTR_SIZE_HOST];
def_type->alignment[DL_PTR_SIZE_HOST] = member->alignment[DL_PTR_SIZE_HOST];
def_type->member_count = 1;
memcpy( def_member, member, sizeof( dl_member_desc ) );
def_member->offset[0] = 0;
def_member->offset[1] = 0;
dl_internal_str_format( def_buffer, sizeof(def_buffer), "{\"a_type_here\":{\"%s\":%.*s}}", dl_internal_member_name( ctx, member ), (int)def_len, read_state->start + def_start );
size_t prod_bytes;
dl_error_t err;
err = dl_txt_pack( ctx, def_buffer, 0x0, 0, &prod_bytes );
if( err != DL_ERROR_OK )
dl_txt_read_failed( ctx, read_state, DL_ERROR_INVALID_DEFAULT_VALUE, "failed to pack default-value for member \"%s\" with error \"%s\"",
dl_internal_member_name( ctx, member ),
dl_error_to_string( err ) );
uint8_t* pack_buffer = (uint8_t*)dl_alloc( &ctx->alloc, prod_bytes );
dl_txt_pack( ctx, def_buffer, pack_buffer, prod_bytes, 0x0 );
// TODO: convert packed instance to typelib endian/ptrsize here!
size_t inst_size = prod_bytes - sizeof( dl_data_header );
ctx->default_data = (uint8_t*)dl_realloc( &ctx->alloc, ctx->default_data, ctx->default_data_size + inst_size, ctx->default_data_size );
memcpy( ctx->default_data + ctx->default_data_size, pack_buffer + sizeof( dl_data_header ), inst_size );
dl_free( &ctx->alloc, pack_buffer );
member->default_value_offset = (uint32_t)ctx->default_data_size;
member->default_value_size = (uint32_t)inst_size;
ctx->default_data_size += inst_size;
--ctx->type_count;
--ctx->member_count;
ctx->typedata_strings_size = name_start;
}
static dl_enum_alias_desc* dl_alloc_enum_alias( dl_ctx_t ctx, dl_txt_read_substr* name )
{
if( ctx->enum_alias_capacity <= ctx->enum_alias_count )
ctx->enum_alias_descs = dl_grow_array( &ctx->alloc, ctx->enum_alias_descs, &ctx->enum_alias_capacity, 0 );
unsigned int alias_index = ctx->enum_alias_count;
++ctx->enum_alias_count;
dl_enum_alias_desc* alias = &ctx->enum_alias_descs[ alias_index ];
alias->value_index = 0xFFFFFFFF;
alias->name = dl_alloc_string( ctx, name );
return alias;
}
static dl_enum_desc* dl_alloc_enum( dl_ctx_t ctx, dl_txt_read_substr* name )
{
if( ctx->enum_capacity <= ctx->enum_count )
{
size_t cap = ctx->enum_capacity;
ctx->enum_ids = dl_grow_array( &ctx->alloc, ctx->enum_ids, &cap, 0 );
ctx->enum_descs = dl_grow_array( &ctx->alloc, ctx->enum_descs, &ctx->enum_capacity, 0 );
}
unsigned int enum_index = ctx->enum_count;
++ctx->enum_count;
ctx->enum_ids[ enum_index ] = dl_internal_hash_buffer( (const uint8_t*)name->str, (size_t)name->len );
dl_enum_desc* e = &ctx->enum_descs[enum_index];
e->name = dl_alloc_string( ctx, name );
e->value_start = ctx->enum_value_count;
e->value_count = 0;
e->alias_count = 0;
e->alias_start = ctx->enum_alias_count;
return e;
}
static void dl_context_load_txt_type_library_read_enum( dl_ctx_t ctx, dl_txt_read_ctx* read_state, dl_txt_read_substr* name )
{
uint32_t value_start = ctx->enum_value_count;
uint32_t alias_start = ctx->enum_alias_count;
const char* values_iter;
const char* type_iter;
const char* end_iter;
dl_txt_read_substr comment = { 0, 0 };
bool is_extern;
dl_context_load_txt_type_library_find_enum_keys(ctx, read_state, name, &comment, &values_iter, &type_iter, &end_iter, &is_extern);
dl_type_storage_t storage = DL_TYPE_STORAGE_CNT;
if(type_iter)
{
read_state->iter = type_iter;
storage = DL_TYPE_STORAGE_CNT;
dl_txt_read_substr type_str = dl_txt_eat_and_expect_string( ctx, read_state );
switch(type_str.len)
{
case 4:
{
if( strncmp("int8", type_str.str, 4) == 0 )
storage = DL_TYPE_STORAGE_ENUM_INT8;
}
break;
case 5:
{
if( strncmp("int16", type_str.str, 5) == 0 ) storage = DL_TYPE_STORAGE_ENUM_INT16;
else if( strncmp("int32", type_str.str, 5) == 0 ) storage = DL_TYPE_STORAGE_ENUM_INT32;
else if( strncmp("int64", type_str.str, 5) == 0 ) storage = DL_TYPE_STORAGE_ENUM_INT64;
else if( strncmp("uint8", type_str.str, 5) == 0 ) storage = DL_TYPE_STORAGE_ENUM_UINT8;
}
break;
case 6:
{
if( strncmp("uint16", type_str.str, 6) == 0 ) storage = DL_TYPE_STORAGE_ENUM_UINT16;
else if( strncmp("uint32", type_str.str, 6) == 0 ) storage = DL_TYPE_STORAGE_ENUM_UINT32;
else if( strncmp("uint64", type_str.str, 6) == 0 ) storage = DL_TYPE_STORAGE_ENUM_UINT64;
}
break;
default:
break;
}
if(storage == DL_TYPE_STORAGE_CNT)
dl_txt_read_failed( ctx, read_state, DL_ERROR_MALFORMED_DATA,
"'type' on enum '%.*s' set to '%.*s', valid types are 'int8', 'int16', 'int32', 'int64', 'uint8', 'uint16', 'uint32' and 'uint64'",
name->len, name->str,
type_str.len, type_str.str );
}
if(storage == DL_TYPE_STORAGE_CNT )
storage = DL_TYPE_STORAGE_ENUM_UINT32; // default to uint32
read_state->iter = values_iter;
dl_txt_eat_char( ctx, read_state, '{' );
do
{
dl_txt_read_substr value_name = dl_txt_eat_and_expect_string( ctx, read_state );
dl_txt_eat_char( ctx, read_state, ':' );
dl_txt_eat_white( read_state );
dl_context_load_txt_type_library_read_enum_values( ctx, storage, read_state, &value_name );
} while( dl_txt_try_eat_char( read_state, ',') );
dl_txt_eat_char( ctx, read_state, '}' );
read_state->iter = end_iter;
// TODO: add test for missing enum value ...
dl_enum_desc* edesc = dl_alloc_enum(ctx, name);
edesc->flags = is_extern ? (uint32_t)DL_TYPE_FLAG_IS_EXTERNAL : 0;
edesc->storage = storage;
edesc->value_count = ctx->enum_value_count - value_start;
edesc->value_start = value_start;
edesc->alias_count = ctx->enum_alias_count - alias_start; /// number of aliases for this enum, always at least 1. Alias 0 is consider the "main name" of the value and need to be a valid c enum name.
edesc->alias_start = alias_start; /// offset into alias list where aliases for this enum-value start.
edesc->comment = comment.len > 0 ? dl_alloc_string( ctx, &comment ) : UINT32_MAX;
}
