static void _test__get_type(_typeinfo_t* pt_info, const char* s_typename)
{
_typenode_t* pt_node = NULL;
assert_true(pt_info != NULL);
assert_true(s_typename != NULL);
strncpy(pt_info->_s_typename, s_typename, _TYPE_NAME_SIZE);
pt_node = _gt_typeregister._apt_bucket[_type_hash(pt_info->_s_typename)];
while (pt_node != NULL) {
if (strncmp(pt_node->_s_typename, pt_info->_s_typename, _TYPE_NAME_SIZE) == 0) {
pt_info->_pt_type = pt_node->_pt_type;
return;
}
pt_node = pt_node->_pt_next;
}
assert_true(false);
}
bool_t _type_register(
size_t t_typesize, const char* s_typename,
ufun_t t_typeinit, bfun_t t_typecopy,
bfun_t t_typeless, ufun_t t_typedestroy)
{
char s_formalname[_TYPE_NAME_SIZE + 1];
_typestyle_t t_style = _TYPE_INVALID;
if (!_gt_typeregister._t_isinit) {
_type_init();
}
/* the main aim is getting formal name */
t_style = _type_get_style(s_typename, s_formalname);
if (t_style == _TYPE_INVALID || _type_is_registered(s_formalname) != NULL || strlen(s_typename) > _TYPE_NAME_SIZE) {
return false;
} else {
size_t t_pos = 0;
_typenode_t* pt_node = (_typenode_t*)_alloc_allocate(&_gt_typeregister._t_allocator, sizeof(_typenode_t), 1);
_type_t* pt_type = (_type_t*)_alloc_allocate(&_gt_typeregister._t_allocator, sizeof(_type_t), 1);
memset(pt_node->_s_typename, '\0', _TYPE_NAME_SIZE + 1);
memset(pt_type->_s_typename, '\0', _TYPE_NAME_SIZE + 1);
/* register the new type */
strncpy(pt_node->_s_typename, s_formalname, _TYPE_NAME_SIZE);
strncpy(pt_type->_s_typename, s_formalname, _TYPE_NAME_SIZE);
pt_type->_t_typesize = t_typesize;
pt_type->_t_style = t_style; /* save type style for type duplication between different type style */
pt_type->_t_typeinit = t_typeinit != NULL ? t_typeinit : _type_init_default;
pt_type->_t_typecopy = t_typecopy != NULL ? t_typecopy : _type_copy_default;
pt_type->_t_typeless = t_typeless != NULL ? t_typeless : _type_less_default;
pt_type->_t_typedestroy = t_typedestroy != NULL ? t_typedestroy : _type_destroy_default;
pt_node->_pt_type = pt_type;
t_pos = _type_hash(s_formalname);
pt_node->_pt_next = _gt_typeregister._apt_bucket[t_pos];
_gt_typeregister._apt_bucket[t_pos] = pt_node;
return true;
}
}
/**
* Test the type is registered or not
*/
_type_t* _type_is_registered(const char* s_typename)
{
_type_t* pt_registered = NULL;
_typenode_t* pt_node = NULL;
assert(s_typename != NULL);
assert(strlen(s_typename) <= _TYPE_NAME_SIZE);
/* get the registered type pointer */
pt_node = _gt_typeregister._apt_bucket[_type_hash(s_typename)];
while (pt_node != NULL) {
if (strncmp(s_typename, pt_node->_s_typename, _TYPE_NAME_SIZE) == 0) {
pt_registered = pt_node->_pt_type;
assert(pt_registered != NULL);
break;
} else {
pt_node = pt_node->_pt_next;
}
}
return pt_registered;
}
bool_t _type_duplicate(
size_t t_typesize1, const char* s_typename1,
size_t t_typesize2, const char* s_typename2)
{
_type_t* pt_registered1 = NULL;
_type_t* pt_registered2 = false;
char s_formalname1[_TYPE_NAME_SIZE + 1];
char s_formalname2[_TYPE_NAME_SIZE + 1];
assert(s_typename1 != NULL);
assert(s_typename2 != NULL);
if (!_gt_typeregister._t_isinit) {
_type_init();
}
if (strlen(s_typename1) > _TYPE_NAME_SIZE ||
strlen(s_typename2) > _TYPE_NAME_SIZE ||
t_typesize1 != t_typesize2) {
return false;
}
_type_get_style(s_typename1, s_formalname1);
_type_get_style(s_typename2, s_formalname2);
/* test the type1 and type2 is registered or not */
pt_registered1 = _type_is_registered(s_formalname1);
pt_registered2 = _type_is_registered(s_formalname2);
if (pt_registered1 == NULL && pt_registered2 == NULL) {
/* type1 and type2 all unregistered */
return false;
} else if (pt_registered1 != NULL && pt_registered2 != NULL) {
/* type1 and type2 all registered */
return pt_registered1 == pt_registered2 ? true : false;
} else {
/* only one type is registered */
size_t t_pos = 0;
char* s_duplicatename = NULL;
_typenode_t* pt_duplicate = NULL;
_type_t* pt_type = NULL;
if (pt_registered1 != NULL && pt_registered2 == NULL) {
/* type1 is registered and type2 is unregistered */
pt_type = pt_registered1;
s_duplicatename = s_formalname2;
} else {
/* type1 is unregistered and type2 is registered */
pt_type = pt_registered2;
s_duplicatename = s_formalname1;
}
/* malloc typenode for unregistered type */
pt_duplicate = (_typenode_t*)_alloc_allocate(&_gt_typeregister._t_allocator, sizeof(_typenode_t), 1);
memset(pt_duplicate->_s_typename, '\0', _TYPE_NAME_SIZE + 1);
strncpy(pt_duplicate->_s_typename, s_duplicatename, _TYPE_NAME_SIZE);
pt_duplicate->_pt_type = pt_type;
t_pos = _type_hash(s_duplicatename);
pt_duplicate->_pt_next = _gt_typeregister._apt_bucket[t_pos];
_gt_typeregister._apt_bucket[t_pos] = pt_duplicate;
return true;
}
}
