void test__type_is_registered__register(void** state)
{
_type_t* pt_type = _type_is_registered("int");
assert_true(pt_type != NULL);
assert_true(pt_type->_t_typesize == sizeof(int));
assert_true(strncmp(pt_type->_s_typename, "int", _TYPE_NAME_SIZE) == 0);
assert_true(pt_type->_t_typeinit == _type_init_int);
assert_true(pt_type->_t_typeless == _type_less_int);
assert_true(pt_type->_t_typecopy == _type_copy_int);
assert_true(pt_type->_t_typedestroy == _type_destroy_int);
}
void test__type_register__register_default(void** state)
{
_type_t* pt_type = NULL;
assert_true(_type_register(sizeof(_test__type_register1_t), "_test__type_register1_t", NULL, NULL, NULL, NULL) == true);
pt_type = _type_is_registered("_test__type_register1_t");
assert_true(pt_type != NULL);
assert_true(pt_type->_t_typesize == sizeof(_test__type_register1_t));
assert_true(strncmp(pt_type->_s_typename, "_test__type_register1_t", _TYPE_NAME_SIZE) == 0);
assert_true(pt_type->_t_style == _TYPE_USER_DEFINE);
assert_true(pt_type->_t_typeinit == _type_init_default);
assert_true(pt_type->_t_typeless == _type_less_default);
assert_true(pt_type->_t_typecopy == _type_copy_default);
assert_true(pt_type->_t_typedestroy == _type_destroy_default);
}
void _type_get_type(_typeinfo_t* pt_typeinfo, const char* s_typename)
{
char s_registeredname[_TYPE_NAME_SIZE + 1];
assert(pt_typeinfo != NULL);
assert(s_typename != NULL);
if (!_gt_typeregister._t_isinit) {
_type_init();
}
s_registeredname[0] = s_registeredname[_TYPE_NAME_SIZE] = '\0';
pt_typeinfo->_t_style = _type_get_style(s_typename, pt_typeinfo->_s_typename);
if (pt_typeinfo->_t_style == _TYPE_INVALID) {
pt_typeinfo->_pt_type = NULL;
return;
} else if (pt_typeinfo->_t_style == _TYPE_C_BUILTIN ||
pt_typeinfo->_t_style == _TYPE_USER_DEFINE) {
strncpy(s_registeredname, pt_typeinfo->_s_typename, _TYPE_NAME_SIZE);
} else {
/* the string_t , range_t and iterator types are special codition */
if (_type_cstl_builtin_special(pt_typeinfo->_s_typename)) {
strncpy(s_registeredname, pt_typeinfo->_s_typename, _TYPE_NAME_SIZE);
} else {
size_t t_length = 0;
char* pc_leftbracket = strchr(pt_typeinfo->_s_typename, _CSTL_LEFT_BRACKET);
assert(pc_leftbracket != NULL);
t_length = pc_leftbracket - pt_typeinfo->_s_typename;
assert(t_length <= _TYPE_NAME_SIZE);
strncpy(s_registeredname, pt_typeinfo->_s_typename, t_length);
s_registeredname[t_length] = '\0';
}
}
if ((pt_typeinfo->_pt_type = _type_is_registered(s_registeredname)) == NULL) {
pt_typeinfo->_t_style = _TYPE_INVALID;
} else {
/*
* types that duplicate between different type style has same type style that saved by type struct.
*/
pt_typeinfo->_t_style = pt_typeinfo->_pt_type->_t_style;
}
}
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;
}
}
bool_t _type_is_same(const char* s_typename1, const char* s_typename2)
{
/* s_typename1 and s_typename2 is formal name */
char s_elemname1[_TYPE_NAME_SIZE + 1];
char s_prefix1[_TYPE_NAME_SIZE + 1];
char s_elemname2[_TYPE_NAME_SIZE + 1];
char s_prefix2[_TYPE_NAME_SIZE + 1];
char* pc_index1 = NULL;
char* pc_leftbracket1 = NULL;
char* pc_rightbracket1 = NULL;
char* pc_comma1 = NULL;
char* pc_index2 = NULL;
char* pc_leftbracket2 = NULL;
char* pc_rightbracket2 = NULL;
char* pc_comma2 = NULL;
assert(s_typename1 != NULL);
assert(s_typename2 != NULL);
s_elemname1[0] = s_elemname1[_TYPE_NAME_SIZE] = '\0';
s_elemname2[0] = s_elemname2[_TYPE_NAME_SIZE] = '\0';
strncpy(s_elemname1, s_typename1, _TYPE_NAME_SIZE);
strncpy(s_elemname2, s_typename2, _TYPE_NAME_SIZE);
do {
pc_leftbracket1 = strchr(s_elemname1, _CSTL_LEFT_BRACKET);
pc_comma1 = strchr(s_elemname1, _CSTL_COMMA);
pc_rightbracket1 = strchr(s_elemname1, _CSTL_RIGHT_BRACKET);
pc_leftbracket2 = strchr(s_elemname2, _CSTL_LEFT_BRACKET);
pc_comma2 = strchr(s_elemname2, _CSTL_COMMA);
pc_rightbracket2 = strchr(s_elemname2, _CSTL_RIGHT_BRACKET);
/* int vs vector<int> or list_t<double> vs string_t */
if ((pc_leftbracket1 != NULL && pc_leftbracket2 == NULL) ||
(pc_leftbracket1 == NULL && pc_leftbracket2 != NULL)) {
return false;
}
pc_index1 =
pc_leftbracket1 != NULL ?
pc_comma1 != NULL ?
pc_rightbracket1 != NULL ?
pc_leftbracket1 < pc_comma1 ?
pc_leftbracket1 < pc_rightbracket1 ? pc_leftbracket1 : pc_rightbracket1
:
pc_comma1 < pc_rightbracket1 ? pc_comma1 : pc_rightbracket1
:
pc_leftbracket1 < pc_comma1 ? pc_leftbracket1 : pc_comma1
:
pc_rightbracket1 != NULL ?
pc_leftbracket1 < pc_rightbracket1 ? pc_leftbracket1 : pc_rightbracket1
:
pc_leftbracket1
:
pc_comma1 != NULL ?
pc_rightbracket1 != NULL ?
pc_comma1 < pc_rightbracket1 ? pc_comma1 : pc_rightbracket1
:
pc_comma1
:
pc_rightbracket1;
pc_index2 =
pc_leftbracket2 != NULL ?
pc_comma2 != NULL ?
pc_rightbracket2 != NULL ?
pc_leftbracket2 < pc_comma2 ?
pc_leftbracket2 < pc_rightbracket2 ? pc_leftbracket2 : pc_rightbracket2
:
pc_comma2 < pc_rightbracket2 ? pc_comma2 : pc_rightbracket2
:
pc_leftbracket2 < pc_comma2 ? pc_leftbracket2 : pc_comma2
:
pc_rightbracket2 != NULL ?
pc_leftbracket2 < pc_rightbracket2 ? pc_leftbracket2 : pc_rightbracket2
:
pc_leftbracket2
:
pc_comma2 != NULL ?
pc_rightbracket2 != NULL ?
pc_comma2 < pc_rightbracket2 ? pc_comma2 : pc_rightbracket2
:
pc_comma2
:
pc_rightbracket2;
if (pc_index1 != NULL && pc_index2 != NULL) {
s_prefix1[0] = s_prefix1[_TYPE_NAME_SIZE] = '\0';
s_prefix2[0] = s_prefix2[_TYPE_NAME_SIZE] = '\0';
strncpy(s_prefix1, s_elemname1, pc_index1 - s_elemname1);
s_prefix1[pc_index1 - s_elemname1] = '\0';
strncpy(s_prefix2, s_elemname2, pc_index2 - s_elemname2);
s_prefix2[pc_index2 - s_elemname2] = '\0';
if (_type_is_registered(s_prefix1) != _type_is_registered(s_prefix2)) {
return false;
}
s_prefix1[0] = s_prefix1[_TYPE_NAME_SIZE] = '\0';
s_prefix2[0] = s_prefix2[_TYPE_NAME_SIZE] = '\0';
strncpy(s_prefix1, pc_index1 + 1, _TYPE_NAME_SIZE);
strncpy(s_prefix2, pc_index2 + 1, _TYPE_NAME_SIZE);
s_elemname1[0] = s_elemname1[_TYPE_NAME_SIZE] = '\0';
s_elemname2[0] = s_elemname2[_TYPE_NAME_SIZE] = '\0';
strncpy(s_elemname1, s_prefix1, _TYPE_NAME_SIZE);
strncpy(s_elemname2, s_prefix2, _TYPE_NAME_SIZE);
} else {
assert(pc_index1 == NULL && pc_index2 == NULL);
if (_type_is_registered(s_elemname1) != _type_is_registered(s_elemname2)) {
return false;
}
}
} while ((pc_leftbracket1 != NULL || pc_comma1 != NULL || pc_rightbracket1 != NULL) &&
(pc_leftbracket2 != NULL || pc_comma2 != NULL || pc_rightbracket2 != NULL));
assert(pc_leftbracket1 == NULL && pc_comma1 == NULL && pc_rightbracket1 == NULL &&
pc_leftbracket2 == NULL && pc_comma2 == NULL && pc_rightbracket2 == NULL);
return true;
}
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;
}
}
bool_t _type_parse_type_descript(char* s_formalname)
{
char s_userdefine[_TYPE_NAME_SIZE + 1];
memset(s_userdefine, '\0', _TYPE_NAME_SIZE+1);
assert(s_formalname != NULL);
/* TYPE_DESCRIPT -> C_BUILTIN | USER_DEFINE | CSTL_BUILTIN */
switch (_gt_typeanalysis._t_token) {
/* TYPE_DESCRIPT -> C_BUILTIN */
case _TOKEN_KEY_CHAR:
case _TOKEN_KEY_SHORT:
case _TOKEN_KEY_INT:
case _TOKEN_KEY_LONG:
case _TOKEN_KEY_FLOAT:
case _TOKEN_KEY_DOUBLE:
case _TOKEN_KEY_SIGNED:
case _TOKEN_KEY_UNSIGNED:
case _TOKEN_KEY_VOID:
case _TOKEN_KEY_CSTL_BOOL:
case _TOKEN_KEY_BOOL:
return _type_parse_c_builtin(s_formalname);
break;
/* TYPE_DESCRIPT -> USER_DEFINE */
case _TOKEN_KEY_STRUCT:
case _TOKEN_KEY_ENUM:
case _TOKEN_KEY_UNION:
case _TOKEN_IDENTIFIER:
if (_type_parse_user_define(s_userdefine)) {
strncat(s_formalname, s_userdefine, _TYPE_NAME_SIZE);
return _type_is_registered(s_userdefine) != NULL ? true : false;
} else {
return false;
}
break;
/* TYPE_DESCRIPT -> CSTL_BUILTIN */
case _TOKEN_KEY_VECTOR:
case _TOKEN_KEY_LIST:
//case _TOKEN_KEY_SLIST:
case _TOKEN_KEY_DEQUE:
case _TOKEN_KEY_STACK:
case _TOKEN_KEY_QUEUE:
//case _TOKEN_KEY_PRIORITY_QUEUE:
case _TOKEN_KEY_SET:
case _TOKEN_KEY_MAP:
case _TOKEN_KEY_HASH_SET:
case _TOKEN_KEY_HASH_MAP:
case _TOKEN_KEY_PAIR:
// case _TOKEN_KEY_STRING:
case _TOKEN_KEY_RANGE:
case _TOKEN_KEY_BASIC_STRING:
case _TOKEN_KEY_ITERATOR:
case _TOKEN_KEY_VECTOR_ITERATOR:
case _TOKEN_KEY_LIST_ITERATOR:
//case _TOKEN_KEY_SLIST_ITERATOR:
case _TOKEN_KEY_DEQUE_ITERATOR:
case _TOKEN_KEY_SET_ITERATOR:
case _TOKEN_KEY_MAP_ITERATOR:
case _TOKEN_KEY_HASH_SET_ITERATOR:
case _TOKEN_KEY_HASH_MAP_ITERATOR:
// case _TOKEN_KEY_STRING_ITERATOR:
case _TOKEN_KEY_INPUT_ITERATOR:
case _TOKEN_KEY_OUTPUT_ITERATOR:
case _TOKEN_KEY_FORWARD_ITERATOR:
case _TOKEN_KEY_BIDIRECTIONAL_ITERATOR:
case _TOKEN_KEY_RANDOM_ACCESS_ITERATOR:
case _TOKEN_KEY_BASIC_STRING_ITERATOR:
return _type_parse_cstl_builtin(s_formalname);
break;
default:
return false;
break;
}
}
void test__type_duplicate__duplicate_second(void** state)
{
assert_true(_type_duplicate(sizeof(struct _test__type_duplicate2), "struct _test__type_duplicate2",
sizeof(_test__type_duplicate2_t), "_test__type_duplicate2_t") == true);
assert_true(_type_is_registered("struct _test__type_duplicate2") != NULL);
}
void test__type_duplicate__duplicate_first(void** state)
{
assert_true(_type_duplicate(sizeof(_test__type_duplicate1_t), "_test__type_duplicate1_t",
sizeof(struct _test__type_duplicate1), "struct _test__type_duplicate1") == true);
assert_true(_type_is_registered("struct _test__type_duplicate1") != NULL);
}
void test__type_is_registered__not_register(void** state)
{
assert_true(_type_is_registered("abcdefghijklmnopqrstuvwxyz") == NULL);
}
void test__type_is_registered__long_typename(void** state)
{
expect_assert_failure(_type_is_registered("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
}
void test__type_is_registered__null_typename(void** state)
{
expect_assert_failure(_type_is_registered(NULL));
}
