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)); }