void* tree_find(tree *t, void *key, tree_cmp_func *cmp, void *data, int *pos)
{
if (!t || !t->array)
return nullptr;
return mybsearch(key, &t->array[0], t->elements, cmp, data, pos);
}
char16* DictList::find_pos2_startedbyhz(char16 hz_char) {
char16 *found_2w = static_cast<char16*>
(mybsearch(&hz_char, buf_ + start_pos_[1],
(start_pos_[2] - start_pos_[1]) / 2,
sizeof(char16) * 2, cmp_hanzis_1));
if (NULL == found_2w)
return NULL;
while (found_2w > buf_ + start_pos_[1] && *found_2w == *(found_2w - 1))
found_2w -= 2;
return found_2w;
}
int mybsearch(void **a, void* b, size_t sizeA, size_t low, size_t high, int (*cmp)(const void *, const void *)){
size_t mid;
int val;
if(high < low){
return -1;
}
mid = avg(low, high);
val = cmp((*a + (mid * sizeA)), b);
if(val > 0){
return mybsearch(a, b, sizeA, low, (mid - 1), cmp);
}
else if(val < 0)
{
return mybsearch(a, b, sizeA, (mid + 1), high, cmp);
}
else
{
return mid;
}
}//end insert
char16* DictList::find_pos_startedbyhzs(const char16 last_hzs[],
size_t word_len, int (*cmp_func)(const void *, const void *)) {
char16 *found_w = static_cast<char16*>
(mybsearch(last_hzs, buf_ + start_pos_[word_len - 1],
(start_pos_[word_len] - start_pos_[word_len - 1])
/ word_len,
sizeof(char16) * word_len, cmp_func));
if (NULL == found_w)
return NULL;
while (found_w > buf_ + start_pos_[word_len -1] &&
cmp_func(found_w, found_w - word_len) == 0)
found_w -= word_len;
return found_w;
}
uint16 DictList::get_splids_for_hanzi(char16 hanzi, uint16 half_splid,
uint16 *splids, uint16 max_splids) {
char16 *hz_found = static_cast<char16*>
(mybsearch(&hanzi, scis_hz_, scis_num_, sizeof(char16), cmp_hanzis_1));
assert(NULL != hz_found && hanzi == *hz_found);
// Move to the first one.
while (hz_found > scis_hz_ && hanzi == *(hz_found - 1))
hz_found--;
// First try to found if strict comparison result is not zero.
char16 *hz_f = hz_found;
bool strict = false;
while (hz_f < scis_hz_ + scis_num_ && hanzi == *hz_f) {
uint16 pos = hz_f - scis_hz_;
if (0 == half_splid || scis_splid_[pos].half_splid == half_splid) {
strict = true;
}
hz_f++;
}
uint16 found_num = 0;
while (hz_found < scis_hz_ + scis_num_ && hanzi == *hz_found) {
uint16 pos = hz_found - scis_hz_;
if (0 == half_splid ||
(strict && scis_splid_[pos].half_splid == half_splid) ||
(!strict && spl_trie_->half_full_compatible(half_splid,
scis_splid_[pos].full_splid))) {
assert(found_num + 1 < max_splids);
splids[found_num] = scis_splid_[pos].full_splid;
found_num++;
}
hz_found++;
}
return found_num;
}
