myhtml_collection_t * myhtml_collection_destroy(myhtml_collection_t *collection)
{
if(collection == NULL)
return NULL;
if(collection->list)
myhtml_free(collection->list);
myhtml_free(collection);
return NULL;
}
/*
* Collections
*/
myhtml_collection_t * myhtml_collection_create(size_t size, myhtml_status_t *status)
{
myhtml_collection_t *collection = (myhtml_collection_t*)myhtml_malloc(sizeof(myhtml_collection_t));
if(collection == NULL) {
if(status)
*status = MyHTML_STATUS_ERROR_MEMORY_ALLOCATION;
return NULL;
}
collection->size = size;
collection->length = 0;
collection->list = (myhtml_tree_node_t **)myhtml_malloc(sizeof(myhtml_tree_node_t*) * size);
if(collection->list == NULL) {
myhtml_free(collection);
if(status)
*status = MyHTML_STATUS_ERROR_MEMORY_ALLOCATION;
return NULL;
}
if(status)
*status = MyHTML_STATUS_OK;
return collection;
}
mythread_queue_t * mythread_queue_destroy(mythread_queue_t* queue)
{
if(queue == NULL)
return NULL;
if(queue->nodes) {
for (size_t i = 0; i <= queue->nodes_pos; i++) {
myhtml_free(queue->nodes[i]);
}
myhtml_free(queue->nodes);
}
myhtml_free(queue);
return NULL;
}
myhtml_t* myhtml_destroy(myhtml_t* myhtml)
{
if(myhtml == NULL)
return NULL;
myhtml_destroy_marker(myhtml);
mythread_destroy(myhtml->thread, true);
myhtml_tokenizer_state_destroy(myhtml);
if(myhtml->insertion_func)
myhtml_free(myhtml->insertion_func);
myhtml_free(myhtml);
return NULL;
}
mchar_async_cache_t * mchar_async_cache_destroy(mchar_async_cache_t *cache, bool self_destroy)
{
if(cache == NULL)
return NULL;
if(cache->nodes)
myhtml_free(cache->nodes);
if(cache->index)
myhtml_free(cache->index);
if(self_destroy) {
myhtml_free(cache);
return NULL;
}
return cache;
}
mythread_queue_list_entry_t * mythread_queue_list_entry_push(mythread_t *mythread, mythread_queue_t *queue, myhtml_status_t *status)
{
mythread_queue_list_t *queue_list = mythread->queue_list;
if(status)
*status = MyHTML_STATUS_OK;
mythread_queue_list_entry_t* entry = (mythread_queue_list_entry_t*)myhtml_calloc(1, sizeof(mythread_queue_list_entry_t));
if(entry == NULL) {
if(status)
*status = MyHTML_STATUS_THREAD_ERROR_QUEUE_MALLOC;
return NULL;
}
entry->thread_param = (mythread_queue_thread_param_t*)myhtml_calloc(mythread->pth_list_size, sizeof(mythread_queue_thread_param_t));
if(entry->thread_param == NULL) {
myhtml_free(entry);
if(status)
*status = MyHTML_STATUS_THREAD_ERROR_QUEUE_MALLOC;
return NULL;
}
size_t idx;
for (idx = mythread->batch_first_id; idx < (mythread->batch_first_id + mythread->batch_count); idx++) {
entry->thread_param[idx].use = mythread->pth_list[idx].data.t_count;
}
entry->queue = queue;
if(mythread->stream_opt == MyTHREAD_OPT_UNDEF) {
mythread_suspend_all(mythread);
}
else if(mythread->stream_opt == MyTHREAD_OPT_STOP) {
mythread_stop_all(mythread);
}
if(queue_list->first) {
queue_list->last->next = entry;
entry->prev = queue_list->last;
queue_list->last = entry;
}
else {
queue_list->first = entry;
queue_list->last = entry;
}
queue_list->count++;
if(mythread->stream_opt != MyTHREAD_OPT_STOP)
mythread_resume_all(mythread);
return entry;
}
mythread_t * mythread_destroy(mythread_t *mythread, bool self_destroy)
{
if(mythread == NULL)
return NULL;
#ifndef MyHTML_BUILD_WITHOUT_THREADS
myhtml_thread_attr_destroy(mythread);
if(mythread->pth_list) {
mythread_resume_all(mythread);
mythread_stream_quit_all(mythread);
mythread_batch_quit_all(mythread);
mythread_wait_all_for_done(mythread);
for (size_t i = mythread->pth_list_root; i < mythread->pth_list_length; i++)
{
myhtml_thread_join(mythread, &mythread->pth_list[i]);
}
myhtml_free(mythread->pth_list);
mythread->pth_list = NULL;
}
if(mythread->queue_list) {
myhtml_free(mythread->queue_list);
}
if(mythread->sem_prefix) {
myhtml_free(mythread->sem_prefix);
mythread->sem_prefix = NULL;
mythread->sem_prefix_length = 0;
}
#endif /* MyHTML_BUILD_WITHOUT_THREADS */
if(self_destroy) {
myhtml_free(mythread);
return NULL;
}
return mythread;
}
mythread_queue_t * mythread_queue_create(size_t size, myhtml_status_t *status)
{
if(status)
*status = MyHTML_STATUS_OK;
if(size < 4096)
size = 4096;
mythread_queue_t* queue = (mythread_queue_t*)myhtml_malloc(sizeof(mythread_queue_t));
if(queue == NULL) {
if(status)
*status = MyHTML_STATUS_THREAD_ERROR_QUEUE_MALLOC;
return NULL;
}
queue->nodes_pos_size = 512;
queue->nodes_size = size;
queue->nodes = (mythread_queue_node_t**)myhtml_calloc(queue->nodes_pos_size, sizeof(mythread_queue_node_t*));
if(queue->nodes == NULL) {
myhtml_free(queue);
if(status)
*status = MyHTML_STATUS_THREAD_ERROR_QUEUE_NODES_MALLOC;
return NULL;
}
mythread_queue_clean(queue);
queue->nodes[queue->nodes_pos] = (mythread_queue_node_t*)myhtml_malloc(sizeof(mythread_queue_node_t) * queue->nodes_size);
if(queue->nodes[queue->nodes_pos] == NULL) {
myhtml_free(queue->nodes);
myhtml_free(queue);
if(status)
*status = MyHTML_STATUS_THREAD_ERROR_QUEUE_NODE_MALLOC;
return NULL;
}
return queue;
}
myhtml_status_t myhtml_hread_mutex_close(mythread_t *mythread, mythread_context_t *ctx)
{
if(ctx->mutex) {
pthread_mutex_destroy(ctx->mutex);
myhtml_free(ctx->mutex);
ctx->mutex = NULL;
}
return MyHTML_STATUS_OK;
}
mycss_stylesheet_t * mycss_stylesheet_destroy(mycss_stylesheet_t* stylesheet, bool self_destroy)
{
mycss_namespace_stylesheet_destroy(&stylesheet->ns_stylesheet, stylesheet->entry, false);
if(self_destroy) {
myhtml_free(stylesheet);
return NULL;
}
return stylesheet;
}
mythread_queue_list_entry_t * mythread_queue_list_entry_delete(mythread_t *mythread, mythread_queue_list_entry_t *entry, bool destroy_queue)
{
mythread_queue_list_t *queue_list = mythread->queue_list;
mythread_queue_list_entry_t *next = entry->next;
mythread_queue_list_entry_t *prev = entry->prev;
if(mythread->stream_opt == MyTHREAD_OPT_UNDEF) {
mythread_suspend_all(mythread);
}
else if(mythread->stream_opt == MyTHREAD_OPT_STOP) {
mythread_stop_all(mythread);
}
if(prev)
prev->next = next;
if(next)
next->prev = prev;
if(queue_list->first == entry)
queue_list->first = next;
if(queue_list->last == entry)
queue_list->last = prev;
if(mythread->stream_opt != MyTHREAD_OPT_STOP)
mythread_resume_all(mythread);
if(destroy_queue && entry->queue)
mythread_queue_destroy(entry->queue);
if(entry->thread_param)
myhtml_free(entry->thread_param);
myhtml_free(entry);
queue_list->count--;
return NULL;
}
myhtml_string_t * myhtml_string_destroy(myhtml_string_t* str, bool destroy_obj)
{
if(str == NULL)
return NULL;
if(str->data && str->mchar && str->node_idx)
mchar_async_free(str->mchar, str->node_idx, str->data);
if(destroy_obj && str)
myhtml_free(str);
return NULL;
}
myhtml_status_t myhtml_thread_attr_destroy(mythread_t *mythread)
{
if(mythread->attr) {
mythread->sys_last_error = pthread_attr_destroy(mythread->attr);
myhtml_free(mythread->attr);
mythread->attr = NULL;
if(mythread->sys_last_error)
return MyHTML_STATUS_THREAD_ERROR_ATTR_DESTROY;
}
return MyHTML_STATUS_OK;
}
mchar_async_t * mchar_async_destroy(mchar_async_t *mchar_async, int destroy_self)
{
if(mchar_async == NULL)
return NULL;
if(mchar_async->nodes)
{
for (size_t node_idx = 0; node_idx < mchar_async->nodes_length; node_idx++)
{
mchar_async_node_t *node = &mchar_async->nodes[node_idx];
mchar_async_cache_destroy(&node->cache, false);
}
myhtml_free(mchar_async->nodes);
mchar_async->nodes = NULL;
}
if(mchar_async->nodes_cache) {
myhtml_free(mchar_async->nodes_cache);
}
if(mchar_async->chunks)
{
for (size_t pos_idx = 0; pos_idx < mchar_async->chunks_pos_length; pos_idx++) {
if(mchar_async->chunks[pos_idx])
{
for (size_t idx = 0; idx < mchar_async->chunks_size; idx++) {
if(mchar_async->chunks[pos_idx][idx].begin)
myhtml_free(mchar_async->chunks[pos_idx][idx].begin);
}
myhtml_free(mchar_async->chunks[pos_idx]);
}
}
myhtml_free(mchar_async->chunks);
mchar_async->chunks = NULL;
}
mchar_async_cache_destroy(&mchar_async->chunk_cache, false);
mchar_async->mcsync = mcsync_destroy(mchar_async->mcsync, 1);
memset(mchar_async, 0, sizeof(mchar_async_t));
if(destroy_self)
myhtml_free(mchar_async);
else
return mchar_async;
return NULL;
}
void mchar_async_mem_malloc(mchar_async_t *mchar_async, mchar_async_node_t *node, mchar_async_chunk_t *chunk, size_t length)
{
if(chunk == NULL)
return;
if(chunk->begin) {
if(length > chunk->size) {
myhtml_free(chunk->begin);
chunk->size = length + mchar_async->origin_size;
chunk->begin = (char*)myhtml_malloc(chunk->size * sizeof(char));
}
}
else {
chunk->size = mchar_async->origin_size;
if(length > chunk->size)
chunk->size = length;
chunk->begin = (char*)myhtml_malloc(chunk->size * sizeof(char));
}
chunk->length = 0;
}
void myhtml_destroy_marker(myhtml_t* myhtml)
{
if(myhtml->marker)
myhtml_free(myhtml->marker);
}
