void free_sentence_disjuncts(Sentence sent)
{
if (NULL != sent->dc_memblock)
{
free(sent->dc_memblock);
sent->dc_memblock = NULL;
}
else if (NULL != sent->Disjunct_pool)
{
pool_delete(sent->Disjunct_pool);
pool_delete(sent->Connector_pool);
sent->Disjunct_pool = NULL;
}
}
void sentence_delete(Sentence sent)
{
if (!sent) return;
sat_sentence_delete(sent);
free_sentence_words(sent);
wordgraph_delete(sent);
string_set_delete(sent->string_set);
free_linkages(sent);
post_process_free(sent->postprocessor);
post_process_free(sent->constituent_pp);
global_rand_state = sent->rand_state;
pool_delete(sent->fm_Match_node);
pool_delete(sent->Table_connector_pool);
free(sent);
}
void
http_header_free(http_header_t *http) {
http_header_clear(http);
if( http->pool && http->free_pool ) {
pool_delete(http->pool);
}
http->pool = 0 ;
}
static void _ensure_pool_delete_releases_all_allocated_memory( void )
{
pool_t * pool;
allocator_counted_t alloc;
allocator_counted_init_default( &alloc );
pool = pool_new( 128, 4, allocator_counted_get( &alloc ) );
pool_delete( pool );
TEST_REQUIRE( allocator_counted_get_current_count( &alloc ) == 0 );
}
static void _ensure_pool_delete_gracefully_handles_cleaned_up_pool( void )
{
pool_t * pool;
allocator_counted_t alloc;
allocator_counted_init_default( &alloc );
pool = pool_new( 128, 4, allocator_counted_get( &alloc ) );
pool_cleanup( pool );
pool_delete( pool );
TEST_REQUIRE( allocator_counted_get_current_count( &alloc ) == 0 );
}
/**
* free all of the hash tables and C_lists
*/
static void power_table_delete(power_table *pt)
{
pool_delete(pt->memory_pool);
for (WordIdx w = 0; w < pt->power_table_size; w++)
{
xfree((char *)pt->l_table[w], pt->l_table_size[w] * sizeof (C_list *));
xfree((char *)pt->r_table[w], pt->r_table_size[w] * sizeof (C_list *));
}
xfree(pt->l_table_size, 2 * pt->power_table_size * sizeof(unsigned int));
xfree(pt->l_table, 2 * pt->power_table_size * sizeof(C_list **));
}
static void _ensure_pool_new_returns_initialised_pool( void )
{
pool_t * pool;
allocator_guarded_t alloc;
allocator_guarded_init_default( &alloc );
pool = pool_new( 128, 4, allocator_guarded_get( &alloc ) );
TEST_REQUIRE( pool );
TEST_REQUIRE( pool->buffer );
TEST_REQUIRE( allocator_guarded_length( pool->buffer ) >= 128 * 4 );
TEST_REQUIRE( pool->next );
TEST_REQUIRE( pool->allocator == allocator_guarded_get( &alloc ) );
pool_delete( pool );
}
int
http_redirect_client_free(http_redirect_client_t *client) {
http_redirect_t *server = client->server;
http_header_clear(&client->http_req);
if( client->send_file ) {
fclose(client->send_file);
}
if( client->sock ) {
sock_close(client->sock);
fdselect_unset(server->fdselect, client->sock, FDSELECT_WRITE);
fdselect_unset(server->fdselect, client->sock, FDSELECT_READ);
}
if( client->pool ) {
pool_delete(client->pool);
}
memset(client, 0, sizeof(*client));
return 0;
}
int
http_redirect_free(http_redirect_t *server) {
if(server->pool) pool_delete(server->pool);
memset(server, 0, sizeof(*server));
return 0;
}
// Destructor.
~qmidinetJackMidiQueue ()
{
pool_delete(m_pool);
delete [] m_items;
}
static int io_server_close(struct io *io)
{
pool_delete(io->pool);
return IO_OK;
}
/* skiplist_delete SKIPLIST
* Delete SKIPLIST and all associated memory. If all data have been inserted
* with skiplist_insert_copy, this will free all associated data, too. */
void skiplist_delete(skiplist S) {
pool_delete(S->P);
xfree(S);
}
void
url_free(url_t *url) {
pool_delete(url->pool);
memset(url, 0, sizeof(*url));
}
static void _ensure_pool_delete_gracefully_handles_null_pool( void )
{
pool_delete( 0 );
}
