code formatting
This commit is contained in:
parent
771aa952a5
commit
63262e4da3
|
@ -44,12 +44,16 @@ SDL_cond * SDL_CreateCond(void)
|
|||
SDL_cond *cond;
|
||||
|
||||
cond = (SDL_cond *) SDL_malloc(sizeof(SDL_cond));
|
||||
if ( cond ) {
|
||||
if (LWP_CondInit (&(cond->cond))<0) {
|
||||
if (cond)
|
||||
{
|
||||
if (LWP_CondInit(&(cond->cond)) < 0)
|
||||
{
|
||||
SDL_DestroyCond(cond);
|
||||
cond = NULL;
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
SDL_OutOfMemory();
|
||||
}
|
||||
return (cond);
|
||||
|
@ -58,7 +62,8 @@ SDL_cond * SDL_CreateCond(void)
|
|||
/* Destroy a condition variable */
|
||||
void SDL_DestroyCond(SDL_cond *cond)
|
||||
{
|
||||
if ( cond ) {
|
||||
if (cond)
|
||||
{
|
||||
LWP_CondDestroy(cond->cond);
|
||||
SDL_free(cond);
|
||||
}
|
||||
|
@ -67,7 +72,8 @@ void SDL_DestroyCond(SDL_cond *cond)
|
|||
/* Restart one of the threads that are waiting on the condition variable */
|
||||
int SDL_CondSignal(SDL_cond *cond)
|
||||
{
|
||||
if ( ! cond ) {
|
||||
if (!cond)
|
||||
{
|
||||
SDL_SetError("Passed a NULL condition variable");
|
||||
return -1;
|
||||
}
|
||||
|
@ -79,7 +85,8 @@ int SDL_CondSignal(SDL_cond *cond)
|
|||
/* Restart all threads that are waiting on the condition variable */
|
||||
int SDL_CondBroadcast(SDL_cond *cond)
|
||||
{
|
||||
if ( ! cond ) {
|
||||
if (!cond)
|
||||
{
|
||||
SDL_SetError("Passed a NULL condition variable");
|
||||
return -1;
|
||||
}
|
||||
|
@ -115,7 +122,8 @@ int SDL_CondWaitTimeout(SDL_cond *cond, SDL_mutex *mutex, Uint32 ms)
|
|||
struct timespec now;
|
||||
struct timespec abstime;
|
||||
|
||||
if ( ! cond ) {
|
||||
if (!cond)
|
||||
{
|
||||
SDL_SetError("Passed a NULL condition variable");
|
||||
return -1;
|
||||
}
|
||||
|
@ -124,7 +132,8 @@ int SDL_CondWaitTimeout(SDL_cond *cond, SDL_mutex *mutex, Uint32 ms)
|
|||
|
||||
abstime.tv_sec = now.tv_sec + (ms / 1000);
|
||||
abstime.tv_nsec = (now.tv_nsec + (ms % 1000) * 1000) * 1000;
|
||||
if ( abstime.tv_nsec > 1000000000 ) {
|
||||
if (abstime.tv_nsec > 1000000000)
|
||||
{
|
||||
abstime.tv_sec += 1;
|
||||
abstime.tv_nsec -= 1000000000;
|
||||
}
|
||||
|
@ -136,5 +145,4 @@ int SDL_CondWaitTimeout(SDL_cond *cond, SDL_mutex *mutex, Uint32 ms)
|
|||
int SDL_CondWait(SDL_cond *cond, SDL_mutex *mutex)
|
||||
{
|
||||
return LWP_CondWait(cond->cond, mutex->id);
|
||||
|
||||
}
|
||||
|
|
|
@ -28,20 +28,24 @@
|
|||
|
||||
#include <ogcsys.h>
|
||||
|
||||
struct SDL_mutex {
|
||||
struct SDL_mutex
|
||||
{
|
||||
u32 id;
|
||||
};
|
||||
|
||||
/* Create a mutex */
|
||||
SDL_mutex *SDL_CreateMutex(void)
|
||||
{
|
||||
SDL_mutex *mutex;
|
||||
SDL_mutex *mutex = NULL;
|
||||
|
||||
/* Allocate mutex memory */
|
||||
mutex = (SDL_mutex *) SDL_malloc(sizeof(*mutex));
|
||||
if ( mutex ) {
|
||||
if (mutex)
|
||||
{
|
||||
LWP_MutexInit(&mutex->id, 0);
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
SDL_OutOfMemory();
|
||||
}
|
||||
return mutex;
|
||||
|
@ -50,7 +54,8 @@ SDL_mutex *SDL_CreateMutex(void)
|
|||
/* Free the mutex */
|
||||
void SDL_DestroyMutex(SDL_mutex *mutex)
|
||||
{
|
||||
if ( mutex ) {
|
||||
if (mutex)
|
||||
{
|
||||
LWP_MutexDestroy(mutex->id);
|
||||
SDL_free(mutex);
|
||||
}
|
||||
|
@ -59,29 +64,24 @@ void SDL_DestroyMutex(SDL_mutex *mutex)
|
|||
/* Lock the semaphore */
|
||||
int SDL_mutexP(SDL_mutex *mutex)
|
||||
{
|
||||
if ( mutex == NULL ) {
|
||||
if (mutex == NULL)
|
||||
{
|
||||
SDL_SetError("Passed a NULL mutex");
|
||||
return -1;
|
||||
}
|
||||
|
||||
return LWP_MutexLock(mutex->id);
|
||||
|
||||
}
|
||||
|
||||
/* Unlock the mutex */
|
||||
int SDL_mutexV(SDL_mutex *mutex)
|
||||
{
|
||||
if ( mutex == NULL ) {
|
||||
if (mutex == NULL)
|
||||
{
|
||||
SDL_SetError("Passed a NULL mutex");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* If we don't own the mutex, we can't unlock it */
|
||||
/* if ( SDL_ThreadID() != mutex->owner ) {
|
||||
SDL_SetError("mutex not owned by this thread");
|
||||
return -1;
|
||||
}*/
|
||||
|
||||
return LWP_MutexUnlock(mutex->id);
|
||||
|
||||
}
|
||||
|
|
|
@ -27,8 +27,6 @@
|
|||
#include "SDL_thread.h"
|
||||
#include "SDL_systhread_c.h"
|
||||
|
||||
|
||||
|
||||
struct SDL_semaphore
|
||||
{
|
||||
Uint32 count;
|
||||
|
@ -42,7 +40,8 @@ SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)
|
|||
SDL_sem *sem;
|
||||
|
||||
sem = (SDL_sem *) SDL_malloc(sizeof(*sem));
|
||||
if ( ! sem ) {
|
||||
if (!sem)
|
||||
{
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
|
@ -51,7 +50,8 @@ SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)
|
|||
|
||||
sem->count_lock = SDL_CreateMutex();
|
||||
sem->count_nonzero = SDL_CreateCond();
|
||||
if ( ! sem->count_lock || ! sem->count_nonzero ) {
|
||||
if (!sem->count_lock || !sem->count_nonzero)
|
||||
{
|
||||
SDL_DestroySemaphore(sem);
|
||||
return NULL;
|
||||
}
|
||||
|
@ -64,14 +64,17 @@ SDL_sem *SDL_CreateSemaphore(Uint32 initial_value)
|
|||
*/
|
||||
void SDL_DestroySemaphore(SDL_sem *sem)
|
||||
{
|
||||
if ( sem ) {
|
||||
if (sem)
|
||||
{
|
||||
sem->count = 0xFFFFFFFF;
|
||||
while ( sem->waiters_count > 0) {
|
||||
while (sem->waiters_count > 0)
|
||||
{
|
||||
SDL_CondSignal(sem->count_nonzero);
|
||||
SDL_Delay(10);
|
||||
}
|
||||
SDL_DestroyCond(sem->count_nonzero);
|
||||
if ( sem->count_lock ) {
|
||||
if (sem->count_lock)
|
||||
{
|
||||
SDL_mutexP(sem->count_lock);
|
||||
SDL_mutexV(sem->count_lock);
|
||||
SDL_DestroyMutex(sem->count_lock);
|
||||
|
@ -84,14 +87,16 @@ int SDL_SemTryWait(SDL_sem *sem)
|
|||
{
|
||||
int retval;
|
||||
|
||||
if ( ! sem ) {
|
||||
if (!sem)
|
||||
{
|
||||
SDL_SetError("Passed a NULL semaphore");
|
||||
return -1;
|
||||
}
|
||||
|
||||
retval = SDL_MUTEX_TIMEDOUT;
|
||||
SDL_LockMutex(sem->count_lock);
|
||||
if ( sem->count > 0 ) {
|
||||
if (sem->count > 0)
|
||||
{
|
||||
--sem->count;
|
||||
retval = 0;
|
||||
}
|
||||
|
@ -104,22 +109,25 @@ int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout)
|
|||
{
|
||||
int retval;
|
||||
|
||||
if ( ! sem ) {
|
||||
if (!sem)
|
||||
{
|
||||
SDL_SetError("Passed a NULL semaphore");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* A timeout of 0 is an easy case */
|
||||
if ( timeout == 0 ) {
|
||||
if (timeout == 0)
|
||||
{
|
||||
return SDL_SemTryWait(sem);
|
||||
}
|
||||
|
||||
SDL_LockMutex(sem->count_lock);
|
||||
++sem->waiters_count;
|
||||
retval = 0;
|
||||
while ( (sem->count == 0) && (retval != SDL_MUTEX_TIMEDOUT) ) {
|
||||
retval = SDL_CondWaitTimeout(sem->count_nonzero,
|
||||
sem->count_lock, timeout);
|
||||
while ((sem->count == 0) && (retval != SDL_MUTEX_TIMEDOUT))
|
||||
{
|
||||
retval = SDL_CondWaitTimeout(sem->count_nonzero, sem->count_lock,
|
||||
timeout);
|
||||
}
|
||||
--sem->waiters_count;
|
||||
--sem->count;
|
||||
|
@ -138,7 +146,8 @@ Uint32 SDL_SemValue(SDL_sem *sem)
|
|||
Uint32 value;
|
||||
|
||||
value = 0;
|
||||
if ( sem ) {
|
||||
if (sem)
|
||||
{
|
||||
SDL_LockMutex(sem->count_lock);
|
||||
value = sem->count;
|
||||
SDL_UnlockMutex(sem->count_lock);
|
||||
|
@ -148,13 +157,15 @@ Uint32 SDL_SemValue(SDL_sem *sem)
|
|||
|
||||
int SDL_SemPost(SDL_sem *sem)
|
||||
{
|
||||
if ( ! sem ) {
|
||||
if (!sem)
|
||||
{
|
||||
SDL_SetError("Passed a NULL semaphore");
|
||||
return -1;
|
||||
}
|
||||
|
||||
SDL_LockMutex(sem->count_lock);
|
||||
if ( sem->waiters_count > 0 ) {
|
||||
if (sem->waiters_count > 0)
|
||||
{
|
||||
SDL_CondSignal(sem->count_nonzero);
|
||||
}
|
||||
++sem->count;
|
||||
|
@ -162,5 +173,3 @@ int SDL_SemPost(SDL_sem *sem)
|
|||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -48,7 +48,6 @@ void *run_thread(void *data)
|
|||
|
||||
int SDL_SYS_CreateThread(SDL_Thread *thread, void *args)
|
||||
{
|
||||
//SDL_SetError("Threads are not supported on this platform");
|
||||
LWP_CreateThread(&thread->handle, run_thread, args, 0, 0, 10);
|
||||
return (0);
|
||||
}
|
||||
|
@ -74,4 +73,3 @@ void SDL_SYS_KillThread(SDL_Thread *thread)
|
|||
{
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
Reference in a new issue