/*
* Create an object cache.
*
* The object cache will let you allocate objects of the same size. It is
* fully MT safe, so you may allocate objects from multiple threads without
* having to do any syncrhonization in the application code.
*
* @param name the name of the object cache. This name may be used for debug
* purposes and may help you track down what kind of object you
* have problems with (buffer overruns, leakage etc)
* @param bufsize the size of each object in the cache
* @param align the alignment requirements of the objects in the cache.
* @return a handle to an object cache if successful, NULL otherwise.
*/
cache_t *
cache_create(const char *name, size_t bufsize, size_t align)
{
cache_t *ret;
char *name_new;
void **ptr;
ret = mc_calloc(1, sizeof(cache_t));
name_new = mc_alloc(strlen(name) + 1);
ptr = mc_calloc(initial_pool_size, bufsize);
if (ret == NULL || name_new == NULL || ptr == NULL ||
pthread_mutex_init(&ret->mutex, NULL) == -1) {
mc_free(ret);
mc_free(name_new);
mc_free(ptr);
return NULL;
}
strncpy(name_new, name, strlen(name) + 1);
ret->name = name_new;
ret->ptr = ptr;
ret->freetotal = initial_pool_size;
ret->bufsize = bufsize;
return ret;
}
acseg_index_t *
acseg_index_init(void)
{
acseg_index_t * ac_index;
acseg_rbtree_node_t * rbtree_sentinel;
mc_collector_t *mc;
acseg_str_t atom;
mc = NULL;
atom.data = NULL;
atom.len = 0;
rbtree_sentinel = (acseg_rbtree_node_t *) mc_calloc(&mc, sizeof(acseg_rbtree_node_t));
ac_index = (acseg_index_t *) mc_calloc(&mc, sizeof(acseg_index_t));
ac_index->state = AC_INDEX_UNFIXED;
ac_index->root = create_index_item(&atom, rbtree_sentinel, &mc);
ac_index->mc = mc;
ac_index->root->failure = ac_index->root;
return ac_index;
}
void *
mc_dlopen(const char *path)
{
struct ext_host *host;
if ((host = mc_calloc(1, sizeof(struct ext_host))) == NULL) {
errno = ENOMEM;
return NULL;
}
#if XIP && !XS_ARCHIVE
/* first look up the linked list */
if ((host->ext = mc_lookup_module(path)) != NULL)
return host;
#endif
if (load_elf(path, &host->base, &host->ext) != 0) {
mc_free(host);
return NULL;
}
#if MC_NUM_XREF > 0
if (host->ext->xrefs != NULL) {
int i;
struct mc_extension *ext = host->ext;
for (i = 0; i < ext->num_xrefs; i++) {
struct mc_xref *xref = &ext->xrefs[i];
xref_stubs[xref->fnum] = xref->fp;
}
}
#endif
return host;
}
static fkw_rbtree_node_value_t*
create_rbtree_value_node(fkw_dict_array_t *dict_array, fkw_word_node_t *word){
u_char *word_value;
fkw_rbtree_node_value_t *node_value;
node_value = (fkw_rbtree_node_value_t*) mc_calloc(
&(dict_array->mc), sizeof(fkw_rbtree_node_value_t));
word_value = (u_char *) mc_calloc(&(dict_array->mc), word->len);
memcpy(word_value, word->word, word->len);
node_value->next = NULL;
node_value->value.len = word->len;
node_value->value.data = word_value;
return node_value;
}
static fkw_rbtree_node_t *
gen_tree_node(fkw_dict_array_t *dict_array, fkw_word_node_t *word){
fkw_rbtree_node_t *node;
node = (fkw_rbtree_node_t*) mc_calloc(&(dict_array->mc), sizeof(fkw_rbtree_node_t) );
node->key = word->hash_key;
node->data = create_rbtree_value_node(dict_array, word);
return node;
}
static fkw_atom_iter_t *
atom_iter_init(unsigned int size)
{
int i;
fkw_atom_t *atom;
fkw_atom_iter_t *atom_iter;
mc_collector_t *mc;
mc = NULL;
atom_iter = (fkw_atom_iter_t *) mc_calloc(&mc, sizeof(fkw_atom_iter_t) );
atom_iter->size = size;
atom_iter->worker_list = NULL;
atom_iter->worker_list_end = NULL;
atom_iter->free_list = NULL;
atom_iter->mc = mc;
i = 0;
while (i < size) {
atom = (fkw_atom_t *) mc_calloc(&(atom_iter->mc), sizeof(fkw_atom_t) );
atom->value.data = NULL;
atom->value.len = 0;
atom->next = NULL;
if (atom_iter->free_list == NULL){
atom_iter->free_list = atom;
} else {
atom->next = atom_iter->free_list;
atom_iter->free_list = atom;
}
i++;
}
return atom_iter;
}
static fkw_word_dict_t *
word_dict_init(fkw_dict_array_t *dict_array, int word_size, int hash_size)
{
fkw_word_dict_t *word_dict;
word_dict = (fkw_word_dict_t *) mc_calloc(&(dict_array->mc), sizeof(fkw_word_dict_t));
word_dict->word_size = word_size;
word_dict->tree_hash = tree_hash_init(dict_array, hash_size);
return word_dict;
}
static acseg_rbtree_node_t *
create_rbtree_node(acseg_rbtree_key_t key, void *data, mc_collector_t **mc)
{
acseg_rbtree_node_t * node;
node = (acseg_rbtree_node_t *) mc_calloc(mc, sizeof(acseg_rbtree_node_t));
node->key = key;
node->data = data;
return node;
}
static void
add_to_result(acseg_result_t *result, acseg_list_t *addon_list)
{
acseg_str_t *new_phrase, *phrase;
acseg_list_item_t *tmp;
tmp = addon_list->first;
while (tmp){
phrase = (acseg_str_t *) tmp->data;
new_phrase = (acseg_str_t *) mc_calloc(&(result->mc), sizeof(acseg_str_t));
new_phrase->data = (u_char *) mc_calloc(&(result->mc), phrase->len + 1);
memcpy(new_phrase->data, phrase->data, phrase->len);
new_phrase->len = phrase->len;
acseg_list_add(result->list, new_phrase, &(result->mc));
result->num = result->num + 1;
tmp = tmp->next;
}
}
static acseg_index_item_t *
create_index_item(acseg_str_t *atom, acseg_rbtree_node_t
*rbtree_sentinel, mc_collector_t **mc)
{
acseg_index_item_t *index_item;
index_item = (acseg_index_item_t *) mc_calloc(mc, sizeof(acseg_index_item_t));
acseg_copy_str_t(&(index_item->atom), atom, mc);
index_item->output = acseg_list_init(mc);
index_item->extra_outputs = acseg_list_init(mc);
index_item->failure = NULL;
index_item->childs_rbtree = (acseg_rbtree_t *) mc_calloc(mc, sizeof(acseg_rbtree_t));
acseg_rbtree_init(index_item->childs_rbtree,
rbtree_sentinel, acseg_rbtree_insert_value);
return index_item;
}
static fkw_dict_array_t*
fkw_dict_init(int hash_size)
{
int i;
fkw_dict_array_t *dict_array;
mc_collector_t *mc;
mc = NULL;
dict_array = (fkw_dict_array_t *) mc_calloc(&mc, sizeof(fkw_dict_array_t));
dict_array->mc = mc;
dict_array->dict_array = (fkw_word_dict_t **) mc_calloc(
&(dict_array->mc), sizeof(fkw_word_dict_t *) * MAX_WORD_SIZE);
for (i = 0; i < MAX_WORD_SIZE; i++){
dict_array->dict_array[i] = word_dict_init(dict_array, i+1, hash_size);
}
return dict_array;
}
static void
fkw_add_to_word_list(fkw_word_list_t *word_list, const char *data, size_t len)
{
fkw_word_t *word;
word = (fkw_word_t *) mc_calloc(&(word_list->mc), sizeof(fkw_word_t) );
word->next = NULL;
word->value.data = mc_calloc(&(word_list->mc), len + 1);
memcpy(word->value.data, data, len);
word->value.len = len;
if (word_list->start == NULL){
word_list->start = word;
word_list->end = word;
} else {
word_list->end->next = word;
word_list->end = word;
}
word_list->num += 1;
}
int main(int argc, char **argv){
mc_collector_t *mc;
mc = NULL;
void *data;
data = (void *) mc_calloc(&mc, 15);
acseg_list_t *list;
list = acseg_list_init(&mc);
acseg_queue_push(list, data, &mc);
acseg_queue_pop(list);
mc_free(data);
mc_destory(mc);
}
static fkw_rbtree_hash_t *
tree_hash_init(fkw_dict_array_t *dict_array, int hash_size)
{
int i;
fkw_rbtree_t **trees;
fkw_rbtree_hash_t *tree_hash;
fkw_rbtree_node_t *rbtree_sentinel;
tree_hash = (fkw_rbtree_hash_t *) mc_calloc(&(dict_array->mc), sizeof(fkw_rbtree_hash_t) );
tree_hash->hash_size = hash_size;
trees = (fkw_rbtree_t **) mc_calloc(&(dict_array->mc), sizeof(fkw_rbtree_t *) * hash_size);
rbtree_sentinel = (fkw_rbtree_node_t *) mc_calloc(&(dict_array->mc), sizeof(fkw_rbtree_node_t) );
for (i = 0; i < hash_size; i++){
trees[i] = (fkw_rbtree_t *) mc_calloc(&(dict_array->mc), sizeof(fkw_rbtree_t) );
fkw_rbtree_init(trees[i], rbtree_sentinel, fkw_rbtree_insert_word_value);
}
tree_hash->trees = trees;
return tree_hash;
}
static acseg_result_t *
acseg_result_init(void)
{
mc_collector_t *mc;
acseg_result_t *result;
mc = NULL;
result = (acseg_result_t *) mc_calloc(&mc, sizeof(acseg_result_t));
result->list = acseg_list_init(&mc);
result->mc = mc;
result->num = 0;
return result;
}
fkw_word_list_t *
fkw_full_seg(fkw_str_t *text, fkw_dict_array_t *dict_array)
{
u_char *start;
fkw_str_t atom_value;
fkw_atom_iter_t *atom_iter;
fkw_word_list_t *word_list;
mc_collector_t *mc;
atom_iter = atom_iter_init(MAX_WORD_SIZE);
mc = NULL;
word_list = (fkw_word_list_t *) mc_calloc(&mc, sizeof(fkw_word_list_t));
word_list->start = NULL;
word_list->end = NULL;
word_list->num = 0;
word_list->mc = mc;
start = text->data;
while ((start - text->data) < text->len) {
atom_value.data = start;
atom_value.len = get_mblen((u_char)start[0]);
atom_iterator_add(atom_iter, &atom_value);
if (atom_iter->free_list == NULL) {
fkw_do_seg(dict_array, atom_iter, word_list);
}
start = start + atom_value.len;
}
fkw_atom_iter_pop(atom_iter);
while (atom_iter->worker_list && atom_iter->worker_list->next){
fkw_do_seg(dict_array, atom_iter, word_list);
fkw_atom_iter_pop(atom_iter);
}
// free atom iter's memory
mc_destory(atom_iter->mc);
return word_list;
}
acseg_index_t *
acseg_index_add(acseg_index_t *acseg_index, acseg_str_t *phrase)
{
int i;
acseg_rbtree_key_t rbtree_key;
acseg_str_t atom;
acseg_str_t * new_phrase;
acseg_rbtree_t *childs_rbtree;
acseg_rbtree_node_t * rbtree_sentinel, *s_node, *insert_node;
acseg_index_item_t *index_item, *new_index_item;
if (acseg_index->state == AC_INDEX_FIXED){
return NULL;
}
childs_rbtree = acseg_index->root->childs_rbtree;
rbtree_sentinel = childs_rbtree->sentinel;
index_item = NULL;
new_index_item = NULL;
i = 0;
while (i < phrase->len) {
atom.data = &(phrase->data[i]);
atom.len = get_mblen(atom.data[0]);
rbtree_key = ord_utf8_wch((char *) atom.data);
s_node = acseg_rbtree_search(childs_rbtree, rbtree_key);
if (s_node == NULL){
break;
} else {
i = i + atom.len;
index_item = (acseg_index_item_t *) s_node->data;
childs_rbtree = index_item->childs_rbtree;
}
}
while (i < phrase->len){
atom.data = &(phrase->data[i]);
atom.len = get_mblen(atom.data[0]);
rbtree_key = ord_utf8_wch((char *) atom.data);
new_index_item = create_index_item(&atom, rbtree_sentinel, &(acseg_index->mc));
// insert node
insert_node = create_rbtree_node(rbtree_key, new_index_item, &(acseg_index->mc));
acseg_rbtree_insert(childs_rbtree, insert_node);
index_item = new_index_item;
childs_rbtree = new_index_item->childs_rbtree;
i = i + atom.len;
}
new_phrase = (acseg_str_t *) mc_calloc(&(acseg_index->mc), sizeof(acseg_str_t));
acseg_copy_str_t(new_phrase, phrase, &(acseg_index->mc));
acseg_list_add(index_item->output, new_phrase, &(acseg_index->mc));
return acseg_index;
}
