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