/* Function: al_destroy_mutex
*/
void al_destroy_mutex(ALLEGRO_MUTEX *mutex)
{
if (mutex) {
_al_mutex_destroy(&mutex->mutex);
al_free(mutex);
}
}
/* Internal function: _al_event_source_free
* Free the resources using by an event source structure. It
* automatically unregisters the event source from all the event
* queues it is currently registered with.
*/
void _al_event_source_free(ALLEGRO_EVENT_SOURCE *es)
{
ALLEGRO_EVENT_SOURCE_REAL *this = (ALLEGRO_EVENT_SOURCE_REAL *)es;
/* Unregister from all queues. */
while (!_al_vector_is_empty(&this->queues)) {
ALLEGRO_EVENT_QUEUE **slot = _al_vector_ref_back(&this->queues);
al_unregister_event_source(*slot, es);
}
_al_vector_free(&this->queues);
_al_mutex_destroy(&this->mutex);
}
/* _al_shutdown_destructors:
* Free the list of destructors. The list should be empty now.
*/
void _al_shutdown_destructors(_AL_DTOR_LIST *dtors)
{
if (!dtors) {
return;
}
/* free resources used by the destructor subsystem */
ASSERT(_al_vector_size(&dtors->dtors) == 0);
_al_vector_free(&dtors->dtors);
_al_mutex_destroy(&dtors->mutex);
al_free(dtors);
}
/* Function: al_join_thread
*/
void al_join_thread(ALLEGRO_THREAD *thread, void **ret_value)
{
ASSERT(thread);
/* If al_join_thread() is called soon after al_start_thread(), the thread
* function may not yet have noticed the STARTING state and executed the
* user's thread function. Hence we must wait until the thread enters the
* STARTED state.
*/
while (thread->thread_state == THREAD_STATE_STARTING) {
al_rest(0.001);
}
switch (thread->thread_state) {
case THREAD_STATE_CREATED: /* fall through */
case THREAD_STATE_STARTED:
_al_mutex_lock(&thread->mutex);
thread->thread_state = THREAD_STATE_JOINING;
_al_cond_broadcast(&thread->cond);
_al_mutex_unlock(&thread->mutex);
_al_cond_destroy(&thread->cond);
_al_mutex_destroy(&thread->mutex);
_al_thread_join(&thread->thread);
thread->thread_state = THREAD_STATE_JOINED;
break;
case THREAD_STATE_STARTING:
ASSERT(thread->thread_state != THREAD_STATE_STARTING);
break;
case THREAD_STATE_JOINING:
ASSERT(thread->thread_state != THREAD_STATE_JOINING);
break;
case THREAD_STATE_JOINED:
ASSERT(thread->thread_state != THREAD_STATE_JOINED);
break;
case THREAD_STATE_DESTROYED:
ASSERT(thread->thread_state != THREAD_STATE_DESTROYED);
break;
case THREAD_STATE_DETACHED:
ASSERT(thread->thread_state != THREAD_STATE_DETACHED);
break;
}
if (ret_value) {
*ret_value = thread->retval;
}
}
/* Function: al_destroy_event_queue
*/
void al_destroy_event_queue(ALLEGRO_EVENT_QUEUE *queue)
{
ASSERT(queue);
_al_unregister_destructor(_al_dtor_list, queue);
/* Unregister any event sources registered with this queue. */
while (_al_vector_is_nonempty(&queue->sources)) {
ALLEGRO_EVENT_SOURCE **slot = _al_vector_ref_back(&queue->sources);
al_unregister_event_source(queue, *slot);
}
ASSERT(_al_vector_is_empty(&queue->sources));
_al_vector_free(&queue->sources);
ASSERT(queue->events_head == queue->events_tail);
_al_vector_free(&queue->events);
_al_cond_destroy(&queue->cond);
_al_mutex_destroy(&queue->mutex);
al_free(queue);
}
/* shutdown_events:
* Clean up after _al_init_events.
*/
static void shutdown_events(void)
{
_al_mutex_destroy(&user_event_refcount_mutex);
}
void _al_win_shutdown_time(void)
{
_al_mutex_destroy(&time_mutex);
}
